LANGCHAIN — What Are the New Integrations for Xata X Langchain Vector Store and Memory Store?

The best way to predict the future is to invent it. — Alan Kay

Xata has introduced new integrations with LangChain, offering vector store and memory store solutions. These integrations enable users to store documents with embeddings and implement a chatbot with long-term memory stored in Xata. Here, we’ll explore the details of these integrations and provide a code example for implementing a Q&A chat bot using Xata’s vector and memory stores.

What is Xata?

Xata is a database platform powered by PostgreSQL, with automatic replication to Elasticsearch. It supports functionality from both Postgres and Elasticsearch, making it suitable for AI applications. It provides client SDKs for TypeScript/JavaScript and Python and has built-in integrations with platforms like GitHub, Vercel, and Netlify.

In addition to the LangChain integrations, Xata offers deep integration with OpenAI for the “ChatGPT on your data” use case.

The Integrations

The new integrations include:

• Xata as a vector store in LangChain for Python and TypeScript/JavaScript applications. This allows storing documents with embeddings in a Xata table and performing vector search on them.
• Xata as a memory store in LangChain for storing chat message history for AI chat sessions.

Each integration comes with code examples, providing comprehensive data solutions for LangChain.

Example: Conversational Q&A with Memory

The following code example demonstrates a conversational Q&A chat bot using Xata as a vector and memory store. This TypeScript application implements the “chat with your data” use case, enabling follow-up questions and utilizing Xata’s vector and memory stores.

// Import required modules
import * as dotenv from "dotenv";
import { XataVectorSearch } from "langchain/vectorstores/xata";
import { OpenAIEmbeddings } from "langchain/embeddings/openai";
import { Document } from "langchain/document";
import { ConversationalRetrievalQAChain } from "langchain/chains";
import { BufferMemory } from "langchain/memory";
import { XataChatMessageHistory } from "langchain/stores/message/xata";
import { ChatOpenAI } from "langchain/chat_models/openai";

import { getXataClient } from "./xata.ts";

dotenv.config();

const client = getXataClient();

// Create the vector store
const table = "docs";
const embeddings = new OpenAIEmbeddings();
const vectorStore = new XataVectorSearch(embeddings, { client, table });

// Add documents to the vector store
const docs = [
  new Document({
    pageContent: "Xata is a Serverless Data platform based on PostgreSQL",
  }),
  new Document({
    pageContent: "Xata offers a built-in vector type that can be used to store and query vectors",
  }),
  new Document({
    pageContent: "Xata includes similarity search",
  }),
];

const ids = await vectorStore.addDocuments(docs);

// Create the chat memory store
const memory = new BufferMemory({
  chatHistory: new XataChatMessageHistory({
    table: "memory",
    sessionId: new Date().toISOString(),
    client,
    createTable: false,
  }),
  memoryKey: "chat_history",
});

// Initialize the LLM to use to answer the question
const model = new ChatOpenAI({});

// Create the chain
const chain = ConversationalRetrievalQAChain.fromLLM(
  model,
  vectorStore.asRetriever(),
  {
    memory,
  }
);

// Ask a question
const question = "What is Xata?";
const res = await chain.call({ question });
console.log("Question: ", question);
console.log(res);

// Ask a follow-up question
const followUpQ = "Can it do vector search?";
const followUpRes = await chain.call({
  question: followUpQ,
});
console.log("Follow-up question: ", followUpQ);
console.log(followUpRes);

// Clear both the vector store and the memory store
await vectorStore.delete({ ids });
await memory.clear();

This example uses Xata as a vector store to index sample documents and as a memory store to store chat messages, providing a complete conversational Q&A experience using LangChain and Xata.

In conclusion, the new integrations with Xata offer powerful capabilities for implementing AI applications with LangChain, enabling efficient data storage, retrieval, and AI interaction.

For further details and updates, visit the LangChain blog and Xata’s website.