Integración de LangChain Chroma: Tutorial completo de Vector Store
Aprenda a integrar LangChain con Chroma para la recuperación avanzada de documentos mediante búsquedas semánticas, flujos de trabajo eficientes y un rendimiento optimizado.
LangChain Chroma La integración es una herramienta de vanguardia que transforma la recuperación de documentos al permitir búsquedas de vectores semánticos. A diferencia de los sistemas tradicionales basados en palabras clave, este enfoque comprende el contexto y el significado de las consultas, lo que lo hace muy eficaz para aplicaciones como atención al cliente, investigación jurídica y gestión del conocimiento. Al combinar... LangChainGracias a las herramientas de orquestación de Chroma con su base de datos vectorial, los usuarios pueden crear sistemas que recuperen los documentos más relevantes en función de la similitud conceptual.
Las principales ventajas incluyen el almacenamiento persistente para incrustaciones, el uso eficiente de la memoria y la rápida velocidad de recuperación. Por ejemplo, una búsqueda de "automóvil" puede mostrar documentos sobre "coches", o una consulta sobre "crecimiento de ingresos" puede mostrar resultados sobre "aumento de ventas". Esto lo hace ideal para gestionar grandes bases de conocimiento con diversas consultas.
La configuración de LangChain Chroma requiere la instalación de varios paquetes de Python, incluidos langchain-chroma y chromadbLos desarrolladores pueden elegir entre implementación local para el desarrollo o implementación en la nube para mayor escalabilidad. Al organizar proyectos con gestión segura de claves API y directorios estructurados, los usuarios pueden evitar problemas comunes como errores de configuración o pérdida de datos.
Para aquellos que buscan flujos de trabajo más simples, Nodo tardío Ofrece una alternativa visual. Permite a los usuarios crear sistemas de recuperación de documentos sin configuraciones complejas de bases de datos, lo que lo hace accesible para usuarios sin conocimientos técnicos. Al automatizar tareas como la generación de incrustaciones y el almacenamiento de vectores, Latenode reduce el tiempo y el esfuerzo de desarrollo.
Ya sea que esté construyendo un sistema de soporte al cliente, realizando una investigación legal o administrando documentación técnica, LangChain Chroma y herramientas como Latenode brindan la flexibilidad y el poder para satisfacer sus necesidades.
El uso de cadena larga y base de datos vectorial de código abierto Chroma para la búsqueda semántica con OpenAILLM de | Código
Prerrequisitos y configuración del entorno
Para configurar el Integración de LangChain ChromaEs esencial utilizar las versiones correctas de los paquetes y administrar las dependencias con cuidado.
Paquetes y dependencias necesarios
La integración entre LangChain y Chroma se basa en varios paquetes clave, cada uno de los cuales contribuye al almacenamiento, la recuperación y el procesamiento de vectores. El paquete principal, langchain-chroma, actúa como conexión entre el marco de LangChain y la base de datos vectorial de Chroma.
Para instalar los paquetes necesarios, utilice los siguientes comandos:
pip install -qU <span class="hljs-string">"langchain-chroma>=0.1.2"</span>
pip install chromadb
pip install langchain
pip install -qU langchain-openai
pip install python-dotenv
langchain-chroma:Proporciona la capa de integración para una interacción perfecta entre LangChain y Chroma.chromadb:Maneja las operaciones principales de la base de datos vectorial.langchain:Proporciona las herramientas fundamentales para el procesamiento de documentos y la orquestación de cadenas.langchain-openai: Permite la incrustación de modelos de OpenAI. Puedes sustituirlo por alternativas comolangchain-google-genaiorlangchain-huggingfacesi es necesario.python-dotenv:Administra las variables de entorno de forma segura.
Un problema común durante la configuración fue compartido por un desbordamiento de pila Usuario mientras crea una aplicación Chat PDF:
"ImportError: No se pudo importar el paquete de Python chromadb. Instálelo con
pip install chromadb" [ 1 ]
Este error suele surgir cuando chromadb Falta o hay conflictos de versiones. Reinstalar o actualizar el paquete resuelve el problema.
Una vez instaladas las dependencias, es momento de organizar tu proyecto y administrar las claves API de forma segura.
Estructura del proyecto y gestión de claves API
Una configuración de proyecto bien estructurada ayuda a evitar errores de configuración y garantiza la protección de los datos confidenciales. A continuación, se sugiere una estructura:
langchain-chroma-project/
├── .env
├── .gitignore
├── main.py
├── documents/
│ └── sample_docs/
├── vector_store/
│ └── chroma_db/
└── requirements.txt
.envUtilice este archivo para almacenar de forma segura las claves de API y las variables de configuración. Nunca debe incluirse en el control de versiones..gitignore: Agrega.envyvector_store/chroma_db/para evitar que se comprometan datos confidenciales y archivos de bases de datos de gran tamaño.
A continuación se muestra un ejemplo de variables de entorno para incluir en el .env archivo:
OPENAI_API_KEY=your_openai_api_key_here
CHROMA_HOST=localhost
CHROMA_PORT=8000
Para cargar estas variables en su aplicación, utilice el python-dotenv paquete. Por ejemplo, el tutorial de Callum Macpherson sobre la implementación de RAG con LangChain y Chroma recomienda usar dotenv.load_dotenv() como un método confiable para administrar claves API de forma segura [ 2 ].
Con su proyecto organizado y las dependencias listas, el siguiente paso es elegir entre la implementación local y en la nube para su configuración de Chroma.
Opciones de implementación de Chroma local o en la nube
Al implementar su Tienda de vectores LangChain ChromaPuede optar por una implementación local o en la nube, según sus necesidades de rendimiento y escalabilidad.
- Despliegue localIdeal para desarrollo y prototipado, ejecutar Chroma localmente proporciona control total y elimina los costos de alojamiento. Sin embargo, puede limitar la escalabilidad y requiere la gestión manual de las copias de seguridad.
- Implementación en la nubeEsta opción ofrece mayor escalabilidad, copias de seguridad automáticas y menor mantenimiento, ya sea mediante el servicio alojado de Chroma o instancias en la nube autogestionadas. La desventaja es el coste adicional del alojamiento y la dependencia de infraestructura externa.
En la mayoría de los proyectos, comenzar con una implementación local permite validar la configuración sin introducir dependencias externas ni latencia de red. Una vez definidos los detalles, la transición a un entorno en la nube permite admitir aplicaciones a mayor escala.
Si bien LangChain Chroma permite capacidades avanzadas de búsqueda vectorial, herramientas como Latenode simplifican el proceso con flujos de trabajo visuales, eliminando la necesidad de configuraciones de bases de datos complejas.
Creación de una tienda de vectores de croma LangChain
Crear un Tienda de vectores de croma LangChain Implica varios pasos clave: cargar documentos, generar incrustaciones, inicializar el almacén y configurar los métodos de recuperación. Cada paso es crucial para construir un sistema eficiente y escalable de recuperación de documentos.
Carga de documentos en LangChain
La carga de documentos sirve como base para la integración de LangChain Chroma. El framework admite varios formatos de archivo y cuenta con cargadores optimizados para distintos tipos de documentos.
Por ejemplo, los documentos PDF se pueden procesar utilizando el PyPDFLoader, que extrae texto conservando la estructura del documento:
<span class="hljs-keyword">from</span> langchain_community.document_loaders <span class="hljs-keyword">import</span> PyPDFLoader
loader = PyPDFLoader(<span class="hljs-string">"path/to/document.pdf"</span>)
documents = loader.load()
<span class="hljs-built_in">print</span>(<span class="hljs-string">f"Loaded <span class="hljs-subst">{<span class="hljs-built_in">len</span>(documents)}</span> pages from PDF"</span>)
Si está manejando varios archivos dentro de una carpeta, el DirectoryLoader Simplifica el proceso cargando por lotes todos los archivos relevantes:
<span class="hljs-keyword">from</span> langchain_community.document_loaders <span class="hljs-keyword">import</span> DirectoryLoader, TextLoader
loader = DirectoryLoader(
<span class="hljs-string">"documents/"</span>,
glob=<span class="hljs-string">"**/*.txt"</span>,
loader_cls=TextLoader,
show_progress=<span class="hljs-literal">True</span>
)
documents = loader.load()
Para el contenido basado en la web, el WebBaseLoader recupera y procesa documentos HTML a partir de URL:
<span class="hljs-keyword">from</span> langchain_community.document_loaders <span class="hljs-keyword">import</span> WebBaseLoader
loader = WebBaseLoader(<span class="hljs-string">"https://example.com/article"</span>)
web_documents = loader.load()
Al trabajar con archivos grandes, dividirlos en fragmentos más pequeños que preserven el contexto se vuelve esencial. RecursiveCharacterTextSplitter Maneja esto efectivamente:
<span class="hljs-keyword">from</span> langchain.text_splitter <span class="hljs-keyword">import</span> RecursiveCharacterTextSplitter
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=<span class="hljs-number">1000</span>,
chunk_overlap=<span class="hljs-number">200</span>,
length_function=<span class="hljs-built_in">len</span>
)
chunks = text_splitter.split_documents(documents)
Este proceso de fragmentación garantiza que los documentos sean manejables y estén listos para su integración y recuperación.
Creación y configuración de incrustaciones
Las incrustaciones son la base de la búsqueda semántica, ya que convierten texto en representaciones numéricas. LangChain Chroma admite varios modelos de incrustación, siendo las incrustaciones de OpenAI una opción popular para entornos de producción.
Para configurar las incrustaciones de OpenAI, necesitará una clave API y un modelo específico:
<span class="hljs-keyword">import</span> os
<span class="hljs-keyword">from</span> langchain_openai <span class="hljs-keyword">import</span> OpenAIEmbeddings
<span class="hljs-keyword">from</span> dotenv <span class="hljs-keyword">import</span> load_dotenv
load_dotenv()
embeddings = OpenAIEmbeddings(
model=<span class="hljs-string">"text-embedding-3-small"</span>,
openai_api_key=os.getenv(<span class="hljs-string">"OPENAI_API_KEY"</span>)
)
Para aquellos que buscan opciones económicas, Abrazando la cara ofrece modelos de incrustación gratuitos:
<span class="hljs-keyword">from</span> langchain_huggingface <span class="hljs-keyword">import</span> HuggingFaceEmbeddings
embeddings = HuggingFaceEmbeddings(
model_name=<span class="hljs-string">"sentence-transformers/all-MiniLM-L6-v2"</span>
)
Antes de continuar, es recomendable probar la configuración de incrustación para asegurarse de que todo funciona correctamente:
<span class="hljs-comment"># Test embedding generation</span>
test_text = <span class="hljs-string">"This is a sample document for testing embeddings."</span>
test_embedding = embeddings.embed_query(test_text)
<span class="hljs-built_in">print</span>(<span class="hljs-string">f"Embedding dimension: <span class="hljs-subst">{<span class="hljs-built_in">len</span>(test_embedding)}</span>"</span>)
Una vez verificadas las incrustaciones, puedes pasar a crear un almacén de vectores persistente.
Inicialización y persistencia del almacén de vectores
La Tienda de vectores de croma Actúa como base de datos para almacenar incrustaciones de documentos. También permite el almacenamiento persistente, lo que permite reutilizar las incrustaciones almacenadas.
Para crear un nuevo almacén de vectores a partir de sus documentos:
<span class="hljs-keyword">from</span> langchain_chroma <span class="hljs-keyword">import</span> Chroma
<span class="hljs-comment"># Create vector store from documents</span>
vectorstore = Chroma.from_documents(
documents=chunks,
embedding=embeddings,
persist_directory=<span class="hljs-string">"./vector_store/chroma_db"</span>
)
<span class="hljs-built_in">print</span>(<span class="hljs-string">f"Vector store created with <span class="hljs-subst">{vectorstore._collection.count()}</span> documents"</span>)
Si ya existe un almacén de vectores, se puede cargar directamente sin tener que volver a crearlo:
<span class="hljs-comment"># Load existing vector store</span>
vectorstore = Chroma(
persist_directory=<span class="hljs-string">"./vector_store/chroma_db"</span>,
embedding_function=embeddings
)
Para administrar varias colecciones dentro de una sola instancia de Chroma, puede especificar un nombre de colección:
<span class="hljs-comment"># Create named collection</span>
vectorstore = Chroma(
collection_name=<span class="hljs-string">"technical_docs"</span>,
embedding_function=embeddings,
persist_directory=<span class="hljs-string">"./vector_store/chroma_db"</span>
)
Al persistir las incrustaciones, se permite una recuperación eficiente, lo que es fundamental para las aplicaciones que requieren búsquedas de documentos rápidas y precisas.
Patrones de indexación y recuperación de documentos
LangChain Chroma proporciona herramientas versátiles para indexar, actualizar y recuperar documentos, lo que lo hace ideal para sistemas de generación aumentada por recuperación (RAG).
Para agregar nuevos documentos:
<span class="hljs-comment"># Add new documents</span>
new_documents = [<span class="hljs-string">"Additional document content here"</span>]
vectorstore.add_texts(
texts=new_documents,
metadatas=[{<span class="hljs-string">"source"</span>: <span class="hljs-string">"manual_addition"</span>, <span class="hljs-string">"date"</span>: <span class="hljs-string">"2025-08-22"</span>}]
)
Para recuperar documentos, la búsqueda por similitud identifica las coincidencias más cercanas según la proximidad del vector:
<span class="hljs-comment"># Perform similarity search</span>
query = <span class="hljs-string">"What are the main features of the product?"</span>
results = vectorstore.similarity_search(
query=query,
k=<span class="hljs-number">3</span> <span class="hljs-comment"># Return top 3 most similar documents</span>
)
<span class="hljs-keyword">for</span> i, doc <span class="hljs-keyword">in</span> <span class="hljs-built_in">enumerate</span>(results):
<span class="hljs-built_in">print</span>(<span class="hljs-string">f"Result <span class="hljs-subst">{i+<span class="hljs-number">1</span>}</span>: <span class="hljs-subst">{doc.page_content[:<span class="hljs-number">200</span>]}</span>..."</span>)
Para incluir métricas de confianza, utilice la búsqueda de similitud con puntuaciones:
<span class="hljs-comment"># Similarity search with scores</span>
results_with_scores = vectorstore.similarity_search_with_score(
query=query,
k=<span class="hljs-number">3</span>
)
<span class="hljs-keyword">for</span> doc, score <span class="hljs-keyword">in</span> results_with_scores:
<span class="hljs-built_in">print</span>(<span class="hljs-string">f"Score: <span class="hljs-subst">{score:<span class="hljs-number">.4</span>f}</span> - Content: <span class="hljs-subst">{doc.page_content[:<span class="hljs-number">150</span>]}</span>..."</span>)
Para obtener resultados más diversos, la búsqueda de relevancia marginal máxima (MMR) equilibra la relevancia con la variedad:
<span class="hljs-comment"># MMR search for diverse results</span>
mmr_results = vectorstore.max_marginal_relevance_search(
query=query,
k=<span class="hljs-number">3</span>,
fetch_k=<span class="hljs-number">10</span>, <span class="hljs-comment"># Fetch more candidates</span>
lambda_mult=<span class="hljs-number">0.7</span> <span class="hljs-comment"># Balance relevance vs diversity</span>
)
Si bien LangChain Chroma se destaca en la gestión de incrustaciones y búsquedas, plataformas como Latenode ofrecen un enfoque más visual para automatizar los flujos de trabajo, lo que reduce la necesidad de un manejo complejo de bases de datos.
Optimización del rendimiento y errores comunes
Una vez configurado el almacén de vectores, optimizar su rendimiento es esencial para lograr una recuperación de datos rápida y precisa. Una configuración optimizada puede aumentar la velocidad de recuperación hasta en un 300 % y la precisión en un 45 % en comparación con la búsqueda de texto básica. Sin embargo, estas mejoras solo son posibles si se comprenden las técnicas de optimización adecuadas y se evitan errores comunes que pueden perjudicar la implementación.
Ajuste del rendimiento de las tiendas Vector
Al trabajar con grandes colecciones de documentos, la indexación por lotes es una forma práctica de acelerar el proceso de ingesta. Añadir documentos uno por uno puede ser lento y consumir muchos recursos, pero procesarlos por lotes reduce la sobrecarga y optimiza el uso de memoria.
<span class="hljs-comment"># Adding documents one by one (inefficient)</span>
<span class="hljs-keyword">for</span> doc <span class="hljs-keyword">in</span> documents:
vectorstore.add_documents([doc])
<span class="hljs-comment"># Adding documents in batches (optimized)</span>
batch_size = <span class="hljs-number">100</span>
<span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> <span class="hljs-built_in">range</span>(<span class="hljs-number">0</span>, <span class="hljs-built_in">len</span>(documents), batch_size):
batch = documents[i:i + batch_size]
vectorstore.add_documents(batch)
<span class="hljs-built_in">print</span>(<span class="hljs-string">f"Processed batch <span class="hljs-subst">{i // batch_size + <span class="hljs-number">1</span>}</span>"</span>)
Otro aspecto clave es ajustar los parámetros de búsqueda. Ajustar valores como k (el número de vecinos más cercanos) y establecer umbrales de similitud garantiza tanto la velocidad como la relevancia en los resultados de búsqueda.
<span class="hljs-comment"># Optimized search configuration</span>
results = vectorstore.similarity_search_with_score(
query=query,
k=<span class="hljs-number">5</span>,
score_threshold=<span class="hljs-number">0.7</span>
)
<span class="hljs-comment"># Filter results based on confidence scores</span>
filtered_results = [(doc, score) <span class="hljs-keyword">for</span> doc, score <span class="hljs-keyword">in</span> results <span class="hljs-keyword">if</span> score >= <span class="hljs-number">0.75</span>]
Una gestión eficiente de la memoria también es vital, especialmente para almacenes de vectores a gran escala. Técnicas como el procesamiento por lotes y la fragmentación ayudan a prevenir problemas de memoria. El uso de las funciones de persistencia de Chroma garantiza la estabilidad al guardar los datos en el disco.
<span class="hljs-comment"># Managing memory with chunking</span>
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=<span class="hljs-number">500</span>,
chunk_overlap=<span class="hljs-number">50</span>,
length_function=<span class="hljs-built_in">len</span>
)
<span class="hljs-comment"># Selecting an efficient embedding model</span>
embeddings = HuggingFaceEmbeddings(
model_name=<span class="hljs-string">"sentence-transformers/all-MiniLM-L6-v2"</span>,
model_kwargs={<span class="hljs-string">'device'</span>: <span class="hljs-string">'cpu'</span>}
)
Para entornos de producción, Nube de croma Ofrece una solución de almacenamiento vectorial sin servidor, que elimina las limitaciones de recursos locales. Promete una rápida creación e implementación de bases de datos (según se informa, en menos de 30 segundos) y ofrece $5 en créditos gratuitos para nuevos usuarios. [ 3 ].
Estas estrategias establecen una base para un rendimiento confiable, preparando su tienda de vectores para aplicaciones del mundo real.
Resolución de problemas comunes
Incluso con una optimización cuidadosa, pueden surgir ciertos desafíos. Un problema frecuente es incrustación de desajustes de dimensiones, que se producen cuando se utilizan diferentes modelos para indexar y consultar. Esta inconsistencia da lugar a representaciones vectoriales incompatibles.
<span class="hljs-comment"># Problem: Dimension mismatch due to different embedding models</span>
<span class="hljs-comment"># Indexing with one model</span>
indexing_embeddings = OpenAIEmbeddings(model=<span class="hljs-string">"text-embedding-3-small"</span>)
vectorstore = Chroma.from_documents(docs, indexing_embeddings)
<span class="hljs-comment"># Querying with another model</span>
query_embeddings = HuggingFaceEmbeddings(model_name=<span class="hljs-string">"all-MiniLM-L6-v2"</span>)
<span class="hljs-comment"># Solution: Use the same embedding model consistently</span>
embeddings = OpenAIEmbeddings(model=<span class="hljs-string">"text-embedding-3-small"</span>)
vectorstore = Chroma.from_documents(docs, embeddings)
results = vectorstore.similarity_search(query)
Otro error común es problemas de persistenciaEsto puede provocar la pérdida de datos si el almacén vectorial no se guarda o restaura correctamente. Especifique siempre un directorio de persistencia y pruebe periódicamente el proceso de restauración para garantizar la integridad de los datos.
<span class="hljs-comment"># Setting up persistence</span>
vectorstore = Chroma(
persist_directory=<span class="hljs-string">"./chroma_db"</span>,
embedding_function=embeddings,
collection_name=<span class="hljs-string">"my_documents"</span>
)
<span class="hljs-comment"># Save the state</span>
vectorstore.persist()
<span class="hljs-built_in">print</span>(<span class="hljs-string">f"Stored <span class="hljs-subst">{vectorstore._collection.count()}</span> documents"</span>)
<span class="hljs-comment"># Test loading the saved data</span>
loaded_store = Chroma(
persist_directory=<span class="hljs-string">"./chroma_db"</span>,
embedding_function=embeddings,
collection_name=<span class="hljs-string">"my_documents"</span>
)
Una fragmentación incorrecta también puede reducir el rendimiento de la recuperación. Los fragmentos demasiado pequeños o demasiado grandes pueden perder significado contextual o reducir la eficiencia. Busque un equilibrio que preserve el contexto y mantenga tamaños manejables.
| Área de optimización | Mejores Prácticas | Impacto |
|---|---|---|
| Indexación | Utilice el procesamiento por lotes (100-500 documentos por lote) | Acelera la ingestión |
| Parámetros de búsqueda | Ajuste k (por ejemplo, 3-5) y establezca umbrales de similitud (≥0.7) | Mejora la relevancia y la velocidad |
| Gestión de la memoria | Divida el texto en 500 a 1000 caracteres y habilite la persistencia | Previene problemas de memoria |
| Consistencia de incrustación | Utilice el mismo modelo para indexar y realizar consultas | Evita desajustes de dimensiones |
| Persistencia | Guarde y pruebe periódicamente los procesos de restauración | Previene la pérdida de datos |
Y por último, configuraciones incorrectas de variables de entorno puede causar problemas de autenticación, especialmente en implementaciones en la nube. El uso de herramientas como Chroma CLI y .env Los archivos simplifican la configuración del entorno y minimizan los errores.
<span class="hljs-comment"># Setting up environment variables for Chroma Cloud</span>
<span class="hljs-keyword">import</span> os
<span class="hljs-keyword">from</span> dotenv <span class="hljs-keyword">import</span> load_dotenv
load_dotenv()
<span class="hljs-comment"># Check required environment variables</span>
required_vars = [<span class="hljs-string">"CHROMA_API_KEY"</span>, <span class="hljs-string">"CHROMA_SERVER_HOST"</span>]
<span class="hljs-keyword">for</span> var <span class="hljs-keyword">in</span> required_vars:
<span class="hljs-keyword">if</span> <span class="hljs-keyword">not</span> os.getenv(var):
<span class="hljs-keyword">raise</span> ValueError(<span class="hljs-string">f"Missing required environment variable: <span class="hljs-subst">{var}</span>"</span>)
Al abordar estos desafíos comunes e implementar las optimizaciones descritas, puede garantizar que su tienda de vectores funcione de manera eficiente y confiable, incluso en condiciones exigentes.
sbb-itb-23997f1
Ejemplos prácticos de código para casos de uso de LangChain Chroma
Esta sección profundiza en las aplicaciones prácticas de LangChain y Chroma, ofreciendo ejemplos paso a paso para gestionar diversos tipos de documentos y tareas de recuperación complejas. Estos ejemplos están diseñados para ayudarle a crear integraciones funcionales y listas para producción.
Configuración de integración rápida en 10 minutos
Ejemplo de código: Configuración de la integración de LangChain + Chroma
Aquí tienes un ejemplo sencillo para integrar LangChain y Chroma en tan solo 10 minutos. Esta configuración se centra en los componentes esenciales necesarios para la mayoría de las aplicaciones de generación aumentada por recuperación (RAG).
<span class="hljs-keyword">import</span> os
<span class="hljs-keyword">from</span> langchain_community.vectorstores <span class="hljs-keyword">import</span> Chroma
<span class="hljs-keyword">from</span> langchain_openai <span class="hljs-keyword">import</span> OpenAIEmbeddings
<span class="hljs-keyword">from</span> langchain.text_splitter <span class="hljs-keyword">import</span> RecursiveCharacterTextSplitter
<span class="hljs-keyword">from</span> langchain_community.document_loaders <span class="hljs-keyword">import</span> TextLoader
<span class="hljs-keyword">from</span> dotenv <span class="hljs-keyword">import</span> load_dotenv
<span class="hljs-comment"># Load environment variables</span>
load_dotenv()
<span class="hljs-comment"># Initialize embeddings</span>
embeddings = OpenAIEmbeddings(
model=<span class="hljs-string">"text-embedding-3-small"</span>,
openai_api_key=os.getenv(<span class="hljs-string">"OPENAI_API_KEY"</span>)
)
<span class="hljs-comment"># Load and split documents</span>
loader = TextLoader(<span class="hljs-string">"sample_document.txt"</span>)
documents = loader.load()
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=<span class="hljs-number">1000</span>,
chunk_overlap=<span class="hljs-number">200</span>,
length_function=<span class="hljs-built_in">len</span>
)
splits = text_splitter.split_documents(documents)
<span class="hljs-comment"># Create vector store with persistence</span>
vectorstore = Chroma.from_documents(
documents=splits,
embedding=embeddings,
persist_directory=<span class="hljs-string">"./chroma_db"</span>,
collection_name=<span class="hljs-string">"quick_setup"</span>
)
<span class="hljs-comment"># Test the setup</span>
query = <span class="hljs-string">"What is the main topic discussed?"</span>
results = vectorstore.similarity_search(query, k=<span class="hljs-number">3</span>)
<span class="hljs-built_in">print</span>(<span class="hljs-string">f"Found <span class="hljs-subst">{<span class="hljs-built_in">len</span>(results)}</span> relevant chunks"</span>)
Este ejemplo demuestra cómo crear un almacén vectorial funcional utilizando valores predeterminados razonables. Emplea incrustación-de-texto-3-pequeño Para realizar incrustaciones rentables, divide los documentos en segmentos de 1,000 caracteres con una superposición de 200 caracteres para preservar el contexto y utiliza persistencia local para mayor confiabilidad.
Para verificar la configuración, puede consultar el almacén de vectores mediante el similarity_search método que recupera los fragmentos de documentos más relevantes en función de la similitud vectorial.
<span class="hljs-comment"># Enhanced search with confidence scores</span>
results_with_scores = vectorstore.similarity_search_with_score(
query=<span class="hljs-string">"main topic"</span>,
k=<span class="hljs-number">5</span>
)
<span class="hljs-keyword">for</span> doc, score <span class="hljs-keyword">in</span> results_with_scores:
<span class="hljs-built_in">print</span>(<span class="hljs-string">f"Score: <span class="hljs-subst">{score:<span class="hljs-number">.3</span>f}</span>"</span>)
<span class="hljs-built_in">print</span>(<span class="hljs-string">f"Content: <span class="hljs-subst">{doc.page_content[:<span class="hljs-number">100</span>]}</span>..."</span>)
<span class="hljs-built_in">print</span>(<span class="hljs-string">"---"</span>)
Combinación de varios tipos de documentos
Almacenamiento unificado de documentos: Este enfoque le permite cargar y procesar documentos de diversos formatos, como PDF, archivos de texto, páginas web y archivos CSV, en un único almacén vectorial de Chroma. Al centralizar su base de conocimientos, simplifica la recuperación de datos en diversas fuentes. [ 4 ].
En casos prácticos, gestionar múltiples tipos de archivos suele ser esencial. Los cargadores de documentos de LangChain facilitan el procesamiento de estos formatos, manteniendo estrategias de fragmentación consistentes.
<span class="hljs-keyword">from</span> langchain_community.document_loaders <span class="hljs-keyword">import</span> (
DirectoryLoader,
PyPDFLoader,
WebBaseLoader,
CSVLoader
)
<span class="hljs-keyword">from</span> pathlib <span class="hljs-keyword">import</span> Path
<span class="hljs-keyword">def</span> <span class="hljs-title function_">load_mixed_documents</span>():
all_documents = []
<span class="hljs-comment"># Load PDFs from directory</span>
pdf_loader = DirectoryLoader(
path=<span class="hljs-string">"./documents/pdfs/"</span>,
glob=<span class="hljs-string">"**/*.pdf"</span>,
loader_cls=PyPDFLoader
)
pdf_docs = pdf_loader.load()
all_documents.extend(pdf_docs)
<span class="hljs-comment"># Load web content</span>
web_urls = [
<span class="hljs-string">"https://example.com/article1"</span>,
<span class="hljs-string">"https://example.com/article2"</span>
]
web_loader = WebBaseLoader(web_urls)
web_docs = web_loader.load()
all_documents.extend(web_docs)
<span class="hljs-comment"># Load CSV data</span>
csv_loader = CSVLoader(
file_path=<span class="hljs-string">"./data/knowledge_base.csv"</span>,
csv_args={<span class="hljs-string">'delimiter'</span>: <span class="hljs-string">','</span>}
)
csv_docs = csv_loader.load()
all_documents.extend(csv_docs)
<span class="hljs-keyword">return</span> all_documents
<span class="hljs-comment"># Process all document types uniformly</span>
documents = load_mixed_documents()
<span class="hljs-comment"># Assign document type metadata</span>
<span class="hljs-keyword">for</span> doc <span class="hljs-keyword">in</span> documents:
<span class="hljs-keyword">if</span> <span class="hljs-built_in">hasattr</span>(doc, <span class="hljs-string">'metadata'</span>):
source = doc.metadata.get(<span class="hljs-string">'source'</span>, <span class="hljs-string">''</span>)
<span class="hljs-keyword">if</span> source.endswith(<span class="hljs-string">'.pdf'</span>):
doc.metadata[<span class="hljs-string">'doc_type'</span>] = <span class="hljs-string">'pdf'</span>
<span class="hljs-keyword">elif</span> source.startswith(<span class="hljs-string">'http'</span>):
doc.metadata[<span class="hljs-string">'doc_type'</span>] = <span class="hljs-string">'web'</span>
<span class="hljs-keyword">elif</span> source.endswith(<span class="hljs-string">'.csv'</span>):
doc.metadata[<span class="hljs-string">'doc_type'</span>] = <span class="hljs-string">'csv'</span>
Al etiquetar cada documento con metadatos, como su tipo, puede filtrar fácilmente los resultados durante la recuperación. Esto garantiza un procesamiento uniforme en todos los formatos, a la vez que conserva la flexibilidad para consultar tipos de documentos específicos.
<span class="hljs-comment"># Create unified vector store</span>
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=<span class="hljs-number">800</span>,
chunk_overlap=<span class="hljs-number">100</span>,
separators=[<span class="hljs-string">""</span>, <span class="hljs-string">""</span>, <span class="hljs-string">" "</span>, <span class="hljs-string">""</span>]
)
splits = text_splitter.split_documents(documents)
<span class="hljs-comment"># Add chunk metadata</span>
<span class="hljs-keyword">for</span> i, split <span class="hljs-keyword">in</span> <span class="hljs-built_in">enumerate</span>(splits):
split.metadata[<span class="hljs-string">'chunk_id'</span>] = i
split.metadata[<span class="hljs-string">'chunk_size'</span>] = <span class="hljs-built_in">len</span>(split.page_content)
vectorstore = Chroma.from_documents(
documents=splits,
embedding=embeddings,
persist_directory=<span class="hljs-string">"./multi_format_db"</span>,
collection_name=<span class="hljs-string">"mixed_documents"</span>
)
<span class="hljs-comment"># Search with document type filtering</span>
<span class="hljs-keyword">def</span> <span class="hljs-title function_">search_by_document_type</span>(<span class="hljs-params">query, doc_type=<span class="hljs-literal">None</span>, k=<span class="hljs-number">5</span></span>):
<span class="hljs-keyword">if</span> doc_type:
<span class="hljs-comment"># Filter by document type using metadata</span>
results = vectorstore.similarity_search(
query=query,
k=k*<span class="hljs-number">2</span>, <span class="hljs-comment"># Get more results to filter</span>
<span class="hljs-built_in">filter</span>={<span class="hljs-string">"doc_type"</span>: doc_type}
)
<span class="hljs-keyword">return</span> results[:k]
<span class="hljs-keyword">else</span>:
<span class="hljs-keyword">return</span> vectorstore.similarity_search(query, k=k)
<span class="hljs-comment"># Example searches</span>
pdf_results = search_by_document_type(<span class="hljs-string">"technical specifications"</span>, <span class="hljs-string">"pdf"</span>)
web_results = search_by_document_type(<span class="hljs-string">"latest updates"</span>, <span class="hljs-string">"web"</span>)
Esta configuración unificada no solo simplifica la gestión de documentos sino que también mejora la precisión de la recuperación al aprovechar los metadatos para el filtrado.
Uso de LangChain Chroma en cadenas RAG
La integración de los almacenes de vectores de Chroma en cadenas RAG (Recuperación-Generación Aumentada) transforma las colecciones de documentos estáticos en sistemas dinámicos basados en consultas. Al combinar la búsqueda vectorial con la generación de modelos de lenguaje, se pueden crear flujos de trabajo de recuperación altamente ágiles.
<span class="hljs-keyword">from</span> langchain.chains <span class="hljs-keyword">import</span> RetrievalQA
<span class="hljs-keyword">from</span> langchain_openai <span class="hljs-keyword">import</span> ChatOpenAI
<span class="hljs-keyword">from</span> langchain.prompts <span class="hljs-keyword">import</span> PromptTemplate
<span class="hljs-comment"># Initialize language model</span>
llm = ChatOpenAI(
model=<span class="hljs-string">"gpt-3.5-turbo"</span>,
temperature=<span class="hljs-number">0.1</span>,
openai_api_key=os.getenv(<span class="hljs-string">"OPENAI_API_KEY"</span>)
)
<span class="hljs-comment"># Create retriever from vector store</span>
retriever = vectorstore.as_retriever(
search_type=<span class="hljs-string">"similarity_score_threshold"</span>,
search_kwargs={
<span class="hljs-string">"k"</span>: <span class="hljs-number">4</span>,
<span class="hljs-string">"score_threshold"</span>: <span class="hljs-number">0.7</span>
}
)
<span class="hljs-comment"># Custom prompt template for RAG</span>
rag_prompt = PromptTemplate(
template=<span class="hljs-string">"""Use the following context to answer the question. If you cannot find the answer in the context, say "I don't have enough information to answer this question."
Context: {context}
Question: {question}
Answer:"""</span>,
input_variables=[<span class="hljs-string">"context"</span>, <span class="hljs-string">"question"</span>]
)
<span class="hljs-comment"># Create RAG chain</span>
rag_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type=<span class="hljs-string">"stuff"</span>,
retriever=retriever,
chain_type_kwargs={<span class="hljs-string">"prompt"</span>: rag_prompt},
return_source_documents=<span class="hljs-literal">True</span>
)
<span class="hljs-comment"># Test the RAG</span>
rag_result = rag_chain({<span class="hljs-string">"question"</span>: <span class="hljs-string">"What is the main topic?"</span>})
<span class="hljs-built_in">print</span>(rag_result)
Este ejemplo demuestra cómo integrar almacenes de vectores de Chroma en una cadena RAG, lo que permite el procesamiento de consultas contextuales y la generación dinámica de contenido. Al combinar la recuperación y el modelado del lenguaje, se pueden crear sistemas que ofrecen respuestas precisas y contextuales.
Nodo tardíoFlujos de trabajo de inteligencia visual de documentos
Latenode simplifica los flujos de trabajo de inteligencia documental con sus herramientas visuales, ofreciendo una alternativa a LangChain Chroma para la recuperación semántica de documentos. Al usar componentes visuales para gestionar la similitud y recuperación de vectores, Latenode elimina la necesidad de configuraciones complejas de bases de datos, haciendo el proceso más ágil y accesible.
Inteligencia documental simplificada, eficiencia similar a la de Chroma
Las herramientas de procesamiento visual de Latenode agilizan el desarrollo y reducen el mantenimiento en comparación con las integraciones de bases de datos vectoriales tradicionales. generador de flujo de trabajo visual permite a los usuarios automatizar modelos de incrustación, almacenamiento de vectores y cadenas de recuperación con funcionalidad de arrastrar y soltar, reduciendo el tiempo y el esfuerzo necesarios para configuraciones con mucho código.
Con su base de datos incorporadaLatenode gestiona automáticamente tareas como la fragmentación, la generación de incrustaciones y la búsqueda de similitudes. No se requieren configuraciones manuales como divisores de texto ni la selección de modelos de incrustación. Este enfoque ofrece las mismas ventajas que LangChain Chroma (recuperación precisa de documentos y respuestas de IA contextuales) sin las dificultades técnicas que supone gestionar una base de datos vectorial.
Soportes de Latenode más de 200 modelos de IA, incluyendo OpenAI, Claude y Gemini, lo que permite el procesamiento fluido de fragmentos de documentos recuperados con cualquier modelo de lenguaje. Al automatizar la extracción de documentos de múltiples fuentes, Latenode elimina la necesidad de cargadores y scripts de preprocesamiento independientes, simplificando aún más el flujo de trabajo.
LangChain Chroma vs. Latenode: Comparación del flujo de trabajo
| Aspecto | Croma de LangChain | Nodo tardío |
|---|---|---|
| Configuración inicial | Instalar dependencias, configurar incrustaciones, configurar la tienda de vectores | Arrastre componentes, conecte fuentes de datos |
| Carga de documentos | Escribe cargadores para cada formato (PDF, CSV, web) | Los conectores incorporados admiten múltiples formatos |
| Gestión de vectores | Configuración y persistencia de incrustación manual | Incorporación y almacenamiento automáticos |
| Lógica de recuperación | Búsqueda de similitud de código y umbrales de puntuación | Componentes de similitud visual con controles de IU |
| Implementación del GAR | Encadenar múltiples componentes programáticamente | Conecte la recuperación a los modelos de IA visualmente |
| Mantenimiento | Actualizar dependencias, administrar versiones de bases de datos | La plataforma gestiona las actualizaciones automáticamente |
| Descamación | Configurar los ajustes del clúster, optimizar las consultas | Escalado automático basado en créditos de ejecución |
| Depuración | Análisis de registros y depuración de código | Historial de ejecución visual y repeticiones |
Los flujos de trabajo de Latenode simplifican la búsqueda semántica y la recuperación de contexto, ofreciendo una alternativa intuitiva y visual a las configuraciones tradicionales.
Ventajas del enfoque de flujo de trabajo visual de Latenode
Una de las características destacadas de Latenode es su velocidad de desarrolloLas tareas que podrían llevar horas para configurar y probar con LangChain Chroma a menudo se pueden realizar en minutos utilizando los componentes prediseñados de Latenode.
Para necesidades avanzadas, Latenode Copiloto de código de IA Une las herramientas visuales con la funcionalidad personalizada. Genera código JavaScript directamente en los flujos de trabajo, lo que permite a los equipos ampliar sus capacidades sin tener que reescribir el código por completo.
La plataforma también destaca en depuraciónEn lugar de revisar archivos de registro, los usuarios pueden rastrear visualmente cada paso del flujo de trabajo de procesamiento de documentos. Si algo falla, se pueden reejecutar segmentos específicos con diferentes parámetros, lo que hace que la resolución de problemas sea mucho más eficiente.
El modelo de precios de Latenode aumenta su atractivo. Con planes desde $19/mesIncluye 5,000 créditos de ejecución y hasta 10 flujos de trabajo activos, lo que ofrece una solución rentable. A diferencia de las configuraciones que requieren una infraestructura de base de datos vectorial independiente, Latenode cobra según el tiempo de ejecución, lo que suele resultar en menores costos operativos.
Para los equipos preocupados por la privacidad de los datos, Latenode ofrece opciones de autohospedaje, lo que permite que los flujos de trabajo se ejecuten en sus propios servidores. Esto garantiza la seguridad de los documentos confidenciales, a la vez que conserva las ventajas de los flujos de trabajo visuales. Además, activadores y respuestas de webhooks Permite el procesamiento de documentos en tiempo real y una integración fluida con los sistemas existentes. En lugar de crear API basadas en LangChain Chroma, Latenode proporciona puntos finales HTTP que gestionan automáticamente la autenticación, la limitación de velocidad y las respuestas a errores.
Estrategias de implementación y escalamiento de producción
La implementación de LangChain Chroma en un entorno de producción requiere una infraestructura bien pensada, una gestión de datos eficiente y una optimización del rendimiento para manejar de manera eficaz los crecientes volúmenes de datos.
Funciones avanzadas de Chroma
De Chroma despliegue en la nube Sus capacidades permiten que los almacenes de vectores de una sola máquina evolucionen a sistemas distribuidos, lo que los hace ideales para cargas de trabajo a escala empresarial. Con funciones como el escalado automático, la gestión de copias de seguridad y la implementación multirregional, Chroma garantiza una transición fluida a operaciones listas para producción.
Para organizaciones que atienden a múltiples clientes o departamentos, arquitecturas multiinquilino Son invaluables. Permiten colecciones aisladas, controles de acceso y cuotas de recursos para diferentes usuarios. Este enfoque reduce los gastos de infraestructura al evitar la necesidad de implementaciones independientes, a la vez que mantiene una sólida seguridad de los datos.
Otra característica clave es rastreo automatizado, que proporciona información sobre el rendimiento de las consultas y la calidad de la incrustación. Mediante la integración de herramientas como Datadog or New RelicLos equipos pueden monitorear y recibir alertas en tiempo real cuando surgen problemas de latencia o la integración de modelos genera resultados inconsistentes. Estas herramientas garantizan que las cargas de trabajo de producción se mantengan eficientes y confiables.
Estas características avanzadas sientan las bases para estrategias de producción escalables y seguras.
Estrategias listas para la producción
Escalar Chroma para producción implica expansión horizontal y sólidas medidas de protección de datos.
Escala horizontal Implica la partición de colecciones en múltiples instancias de Chroma. Esto se puede lograr mediante la fragmentación según el tipo de documento, rangos de fechas o categorías de contenido, lo que garantiza respuestas rápidas a las consultas incluso a medida que crece el volumen de datos.
Poner en marcha protocolos de copia de seguridad y recuperación ante desastres Es fundamental proteger tanto las incrustaciones vectoriales como los metadatos. Estrategias como las copias de seguridad incrementales periódicas, las instantáneas completas y la replicación entre regiones minimizan la pérdida de datos y mejoran la resiliencia, especialmente en aplicaciones críticas.
Conocer Normas de protección de datos de EE. UU. Como SOC 2 Tipo II e HIPAA, las organizaciones deben implementar el cifrado de datos en reposo y en tránsito, mantener registros de auditoría para todas las operaciones de vector y establecer controles de residencia de datos. Medidas adicionales, como claves de cifrado administradas por el cliente y conectividad de red privada, refuerzan aún más el cumplimiento normativo y la seguridad.
Al adoptar estas estrategias, las implementaciones pueden escalar de manera eficiente y al mismo tiempo garantizar la seguridad y el cumplimiento normativo.
Escalabilidad para grandes colecciones de documentos
Al manejar grandes colecciones de documentos, escala horizontal Se vuelve esencial. Técnicas como el hash consistente o el particionamiento basado en rangos distribuyen las operaciones vectoriales entre múltiples instancias de Chroma, lo que permite el procesamiento en paralelo y mantiene un alto rendimiento de las consultas.
A medida que las colecciones crecen, optimización de memoria Desempeña un papel crucial. Algoritmos como HNSW, con parámetros ajustados, reducen el uso de memoria a la vez que mantienen altas tasas de recuperación. Para la ingesta de datos a gran escala, la incrustación por lotes y las inserciones masivas optimizan el rendimiento y evitan cuellos de botella en la memoria durante picos de actividad.
Si bien escalar la infraestructura es necesario, simplificar los flujos de trabajo sigue siendo igualmente importante. Aquí es donde Latenode destaca. Sus flujos de trabajo visuales automatizan tareas como la búsqueda semántica y la recuperación de contexto, lo que permite a los equipos de producción centrarse en las prioridades del negocio en lugar de lidiar con una infraestructura compleja.
Acelere el desarrollo de soluciones de IA basadas en documentos con la plataforma de procesamiento visual de Latenode: una alternativa eficiente a LangChain Chroma para construir sistemas escalables e inteligentes.
Preguntas Frecuentes
¿Cómo la integración de LangChain con Chroma mejora la recuperación de documentos en comparación con los métodos tradicionales basados en palabras clave?
La integración de LangChain con Chroma lleva la recuperación de documentos a un nuevo nivel al aprovechar incrustaciones vectoriales para la búsqueda semántica. A diferencia de los sistemas tradicionales basados en palabras clave que dependen de coincidencias exactas de términos, la búsqueda semántica se centra en la contexto y significado detrás de las palabras, lo que lo hace ideal para manejar consultas complejas o matizadas.
Chroma organiza los documentos mediante sus incrustaciones, lo que le permite recuperar información relevante incluso cuando no se encuentran palabras clave específicas. Este método no solo garantiza resultados más precisos, sino que también aumenta la eficiencia. generación aumentada de recuperación (RAG) aplicaciones, donde mantener la precisión y el contexto es esencial.
¿Cómo puedo configurar un almacén de vectores Chroma LangChain para la búsqueda semántica?
Para configurar un almacén vectorial Chroma de LangChain para búsqueda semántica, comience instalando la base de datos Chroma y configúrela en su entorno LangChain. Una vez lista la base de datos, cree un almacén vectorial en LangChain, seleccionando Chroma como backend de almacenamiento. Prepare sus documentos generando incrustaciones con un modelo adecuado y luego almacénelas en la base de datos vectorial Chroma.
Para garantizar una recuperación eficiente y precisa, ajuste la configuración, como las métricas de similitud y las estrategias de indexación, según sus necesidades específicas. Para una usabilidad a largo plazo, habilite la persistencia de la base de datos para conservar los datos y planificar futuras actualizaciones. Siguiendo las prácticas recomendadas en el preprocesamiento de documentos y la generación de incrustaciones, puede mejorar significativamente la relevancia y la precisión de sus resultados de búsqueda.
¿Cómo hace Latenode para que la creación de sistemas de recuperación de documentos sea más sencilla en comparación con los métodos tradicionales?
Latenode simplifica la creación de sistemas de recuperación de documentos al proporcionar una plataforma visual sin código que automatiza procesos complejos como la similitud vectorial y la búsqueda semántica. Los enfoques tradicionales suelen exigir un profundo conocimiento de las incrustaciones vectoriales y la gestión de bases de datos, lo que puede suponer una barrera para muchos. Latenode elimina esta complejidad, permitiendo a los usuarios crear flujos de trabajo sin necesidad de conocimientos técnicos.
Al simplificar estas tareas, Latenode no solo acorta los plazos de desarrollo, sino que también elimina las complicaciones del mantenimiento de la infraestructura de la base de datos. Esto permite a los equipos concentrarse en mejorar las funciones de la aplicación y obtener resultados con mayor rapidez, abriendo los sistemas de recuperación de documentos a un público más amplio y mejorando la eficiencia.
Artículos relacionados con
