How to have metadata filtering in Supabase hybrid search ?

[abhishekmg]

Checked other resources

• I added a very descriptive title to this question.
• I searched the LangChain documentation with the integrated search.
• I used the GitHub search to find a similar question and didn't find it.

Commit to Help

• I commit to help with one of those options 👆

Example Code

const retriever = new SupabaseHybridSearch(embeddings, {
				client,
				//  Below are the defaults, expecting that you set up your supabase table and functions according to the guide above. Please change if necessary.
				similarityK: 3,
				keywordK: 3,
				tableName: "documents",
				similarityQueryName: "match_documents",
				keywordQueryName: "kw_match_documents",
				metadata: { user_id: userData?.data?.user?.id }, // adding this does not work
				verbose: true,
			});

			const results = await retriever.invoke(bodyData?.query);

### Description

this documentation https://js.langchain.com/v0.2/docs/integrations/retrievers/supabase-hybrid/ does not tell how to filter based on metadata

even after adding `metadata: { user_id: userData?.data?.user?.id }` makes no difference. I get all the data in the `documents` table and the metadata filter does not take effect

there are some issues related to this in git but none give a direct solution

### System Info

macOs Montery 
node version 18.17.1

[dosubot[bot]]

Hey @abhishekmg! I'm here to help you with any issues you're facing. I'm a bot that can assist you in solving bugs, answering questions, and becoming a contributor. Let's tackle this together!

To implement metadata filtering in Supabase hybrid search, you need to ensure that the metadata is correctly passed and utilized in the search queries. Here is an example of how you can achieve this:

1. Ensure your Supabase table and functions are set up correctly:

   -- Enable the pgvector extension to work with embedding vectors
   create extension vector;
   
   -- Create a table to store your documents
   create table documents (
     id bigserial primary key,
     content text, -- corresponds to Document.pageContent
     metadata jsonb, -- corresponds to Document.metadata
     embedding vector(1536) -- 1536 works for OpenAI embeddings, change if needed
   );
   
   -- Create a function to search for documents
   create function match_documents (
     query_embedding vector(1536),
     match_count int DEFAULT null,
     filter jsonb DEFAULT '{}'
   ) returns table (
     id bigint,
     content text,
     metadata jsonb,
     embedding jsonb,
     similarity float
   )
   language plpgsql
   as $$
   #variable_conflict use_column
   begin
     return query
     select
       id,
       content,
       metadata,
       (embedding::text)::jsonb as embedding,
       1 - (documents.embedding <=> query_embedding) as similarity
     from documents
     where metadata @> filter
     order by documents.embedding <=> query_embedding
     limit match_count;
   end;
   $$;

2. Use the SupabaseHybridSearch class with metadata filtering:

   import { SupabaseHybridSearch } from "@langchain/community/retrievers/supabase";
   import { OpenAIEmbeddings } from "@langchain/openai";
   import { createClient } from "@supabase/supabase-js";
   
   const client = createClient(process.env.SUPABASE_URL, process.env.SUPABASE_PRIVATE_KEY);
   const embeddings = new OpenAIEmbeddings();
   
   const retriever = new SupabaseHybridSearch(embeddings, {
     client,
     similarityK: 3,
     keywordK: 3,
     tableName: "documents",
     similarityQueryName: "match_documents",
     keywordQueryName: "kw_match_documents",
     metadata: { user_id: userData?.data?.user?.id }, // Ensure this is correctly set
     verbose: true,
   });
   
   const results = await retriever.invoke(bodyData?.query);
   console.log(results);

In this setup, the metadata field is used to filter the documents based on the specified criteria. Ensure that the metadata you are passing matches the structure and values stored in your Supabase table.

For more details, you can refer to the LangChain documentation on Supabase hybrid search ^[1][2][3].

To continue talking to Dosu, mention @dosu.

[abhishekmg]

I think the above solution is for similaritySearch alone, how can be make this work in hybrid search using SupabaseHybridSearch ?

[dosubot[bot]]

To implement metadata filtering in a hybrid search using SupabaseHybridSearch, you need to define the filtering logic using the SupabaseFilterRPCCall and apply it during the hybrid search. Here is how you can do it:

1. Define the Metadata Filters: Create functions that define the filtering criteria using the filter method on the rpc object.

   const funcFilter: SupabaseFilterRPCCall = (rpc) =>
     rpc.filter("metadata->>user_id", "eq", userData?.data?.user?.id);

2. Apply the Filters in Hybrid Search: Use these filter functions when performing the hybrid search to ensure that the results are filtered based on the specified metadata criteria.

   const result = await retriever.hybridSearch("your_query", 3, funcFilter);

3. Verify the Results: Log the results to verify that the filtering is working as expected.

   console.log(result);

Here is the complete code snippet for reference:

import {
  SupabaseFilterRPCCall,
  SupabaseHybridSearch,
} from "@langchain/community/retrievers/supabase";
import { OpenAIEmbeddings } from "@langchain/openai";
import { createClient } from "@supabase/supabase-js";

const privateKey = process.env.SUPABASE_PRIVATE_KEY;
if (!privateKey) throw new Error(`Expected env var SUPABASE_PRIVATE_KEY`);

const url = process.env.SUPABASE_URL;
if (!url) throw new Error(`Expected env var SUPABASE_URL`);

export const run = async () => {
  const client = createClient(url, privateKey);

  const embeddings = new OpenAIEmbeddings();

  const retriever = new SupabaseHybridSearch(embeddings, {
    client,
    similarityK: 3,
    keywordK: 3,
    tableName: "documents",
    similarityQueryName: "match_documents",
    keywordQueryName: "kw_match_documents",
  });

  const funcFilter: SupabaseFilterRPCCall = (rpc) =>
    rpc.filter("metadata->>user_id", "eq", userData?.data?.user?.id);

  const result = await retriever.hybridSearch("your_query", 3, funcFilter);

  console.log(result);
};

By following these steps, you can ensure that the metadata filtering works correctly in your hybrid search setup using SupabaseHybridSearch ^[1][2].

To continue talking to Dosu, mention @dosu.

[abhishekmg]

This does not work

Property 'hybridSearch' is protected and only accessible within class 'SupabaseHybridSearch' and its subclasses.

[dosubot[bot]]

To correctly implement metadata filtering in a hybrid search using SupabaseHybridSearch, you should use the SupabaseVectorStore class and its similaritySearch method, which allows you to apply filters to your search queries. Here is an example of how you can achieve this:

1. Set Up Your Supabase Table and Functions:
   Ensure your Supabase table and functions are set up correctly to support hybrid search. Here are the SQL commands you need:

   -- Enable the pgvector extension to work with embedding vectors
   create extension vector;
   
   -- Create a table to store your documents
   create table documents (
     id bigserial primary key,
     content text, -- corresponds to Document.pageContent
     metadata jsonb, -- corresponds to Document.metadata
     embedding vector(1536) -- 1536 works for OpenAI embeddings, change if needed
   );
   
   -- Create a function to similarity search for documents
   create function match_documents (
     query_embedding vector(1536),
     match_count int DEFAULT null,
     filter jsonb DEFAULT '{}'
   ) returns table (
     id bigint,
     content text,
     metadata jsonb,
     similarity float
   )
   language plpgsql
   as $$
   #variable_conflict use_column
   begin
     return query
     select
       id,
       content,
       metadata,
       1 - (documents.embedding <=> query_embedding) as similarity
     from documents
     where metadata @> filter
     order by documents.embedding <=> query_embedding
     limit match_count;
   end;
   $$;
   
   -- Create a function to keyword search for documents
   create function kw_match_documents(query_text text, match_count int)
   returns table (id bigint, content text, metadata jsonb, similarity real)
   as $$
   begin
   return query execute
   format('select id, content, metadata, ts_rank(to_tsvector(content), plainto_tsquery($1)) as similarity
   from documents
   where to_tsvector(content) @@ plainto_tsquery($1)
   order by similarity desc
   limit $2')
   using query_text, match_count;
   end;
   $$ language plpgsql;

2. Use the SupabaseVectorStore Class with Metadata Filtering:
   Here is an example of how to use the SupabaseVectorStore class to perform similarity searches with metadata filtering:

   import { SupabaseVectorStore } from "@langchain/community/vectorstores/supabase";
   import { OpenAIEmbeddings } from "@langchain/openai";
   import { createClient } from "@supabase/supabase-js";
   
   const privateKey = process.env.SUPABASE_PRIVATE_KEY;
   if (!privateKey) throw new Error(`Expected env var SUPABASE_PRIVATE_KEY`);
   
   const url = process.env.SUPABASE_URL;
   if (!url) throw new Error(`Expected env var SUPABASE_URL`);
   
   export const run = async () => {
     const client = createClient(url, privateKey);
   
     const vectorStore = await SupabaseVectorStore.fromTexts(
       ["Hello world", "Hello world", "Hello world"],
       [{ user_id: 2 }, { user_id: 1 }, { user_id: 3 }],
       new OpenAIEmbeddings(),
       {
         client,
         tableName: "documents",
         queryName: "match_documents",
       }
     );
   
     const result = await vectorStore.similaritySearch("Hello world", 1, {
       user_id: 3,
     });
   
     console.log(result);
   };

In this example, the SupabaseVectorStore class is used to perform similarity searches with metadata filtering. The similaritySearch method allows you to pass a filter object to apply specific conditions to your search queries ^[1][2][3].

To continue talking to Dosu, mention @dosu.

[abhishekmg]

lol this going in circles, this implementation again goes back to similaritySearch not hybrid search