LANGCHAIN — Is Timescale Vector X LangChain Making PostgreSQL a Better Vector Database for AI Applications?

Technology’s future is in the hands of the dreamers, not the regulators. — Robin Chase

Timescale Vector integration with LangChain brings the power of PostgreSQL as a vector database for AI applications, enabling faster similarity search and efficient time-based context retrieval. In this tutorial, we’ll dive into the unique capabilities of Timescale Vector and provide code snippets to demonstrate how to leverage its features in LangChain.

Faster Vector Similarity Search in PostgreSQL

Timescale Vector speeds up Approximate Nearest Neighbor (ANN) search on large scale vector datasets, enhancing pgvector with a state-of-the-art ANN index inspired by the DiskANN algorithm. Using Timescale Vector’s DiskANN, HNSW, or IVFFLAT indexes in LangChain is incredibly straightforward:

from langchain.vectorstores.timescalevector import TimescaleVector

# Create a Timescale Vector instance from the collection of documents
db = TimescaleVector.from_documents(
   embedding=embeddings,
   documents=docs,
   collection_name=COLLECTION_NAME,
   service_url=SERVICE_URL,
)

# Create a Timescale Vector index
db.create_index()

You can also specify the exact parameters for index creation:

# Create an timescale vector index (DiskANN) with specified parameters
db.create_index(index_type="tsv", max_alpha=1.0, num_neighbors=50)

Add Efficient Time-Based Search Functionality to Your LangChain AI Application

Timescale Vector optimizes time-based vector search by leveraging the automatic time-based partitioning and indexing of Timescale’s hypertables. You can take advantage of this feature by creating a Timescale Vector instance from the collection of documents and specifying the time partition interval:

# Create a Timescale Vector instance from the collection of documents
db = TimescaleVector.from_documents(
     embedding=embeddings,
     ids = [doc.metadata["id"] for doc in docs],
     documents=docs,
     collection_name=COLLECTION_NAME,
     service_url=SERVICE_URL,
     time_partition_interval=timedelta(days = 7),
)

Powering Retrieval Augmented Generation With Time-Based Context Retrieval in LangChain Applications with Timescale Vector

To power Retrieval Augmented Generation (RAG) with time-based context retrieval, you can create a retriever from the TimescaleVector store and use it in a RetrievalQA chain:

# Set timescale vector as a retriever and specify start and end dates via kwargs
retriever = db.as_retriever(search_kwargs={"start_date": start_dt, "end_date": end_dt})

# Create a RetrievalQA chain
qa_stuff = RetrievalQA.from_chain_type(
   llm=llm,
   chain_type="stuff",
   retriever=retriever,
   verbose=True,
)

# Query the RetrievalQA chain
response = qa_stuff.run(query)
print(response)

Advanced LangChain Self-Querying Capabilities With Timescale Vector

Timescale Vector also supports one of LangChain’s coolest features: the Self-Querying retriever. You can create a self-query retriever from the TimescaleVector store and use it to perform complex searches over your vector store without writing any SQL directly:

# Instantiate the self-query retriever from an LLM
retriever = SelfQueryRetriever.from_llm(
   llm, vectorstore, document_content_description, metadata_field_info, enable_limit=True, verbose=True
)

# Query the self-query retriever
retriever.get_relevant_documents("What commits about timescaledb_functions did Sven Klemm add?")

By leveraging Timescale Vector’s advanced features, LangChain developers can build better AI applications with PostgreSQL as their vector database. For more detailed tutorials and resources, you can explore the Up and Running Tutorial, Self-query retriever tutorial, Timescale Vector explainer, and Timescale Vector website.

With Timescale offering a free 90-day trial for LangChain users, now is the perfect time to test and develop your applications with Timescale Vector.