WeAviate fetch similar vector #5656

lakshya29154 · 2024-06-04T12:25:06Z

lakshya29154
Jun 4, 2024

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

import * as fs from "fs";
import { config } from 'dotenv';
import { createHash } from 'crypto';
import { RecursiveCharacterTextSplitter } from "langchain/text_splitter";
import { OpenAIEmbeddings } from "@langchain/openai";
import weaviate, { ApiKey } from "weaviate-ts-client";
import { WeaviateStore } from "@langchain/weaviate";
// import { API_URL_PROMPT_TEMPLATE } from "./test20";
import { OpenAI } from "@langchain/openai";
import { PromptTemplate } from "@langchain/core/prompts";
config();

const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
const model = new OpenAI({ temperature: 0, apiKey: OPENAI_API_KEY });
const API_URL_PROMPT_TEMPLATE1 = `You are given the below the embedding fo some swagger Documentation:
{api_docs}
Using this embeddings, find the relevant API URLs there can be multiple url so give all the url step by step give the method also.

You should build the API URLs in order to get a response that is as short as possible, while still getting the necessary information to answer the question. Pay attention to deliberately exclude any unnecessary pieces of data in the API call.
Question:{question}
API url:`;
const API_URL_PROMPT_TEMPLATE = /* #__PURE__ */ new PromptTemplate({
    inputVariables: ["api_docs", "question"],
    template: API_URL_PROMPT_TEMPLATE1,
  });
// async function getValidData(apiJson)
// {
//     const API_URL_PROMPT_TEMPLATE2 = `You are given the below the mebedding fo some swagger json data:
//     {api_docs}
//     From this json data you have to fetch only those data which are required to recommend the api like its endpoint description method like You will get a question
//     like you will get a question give me the api for .... so from the data you need to find the api and give it as response so for now from all the swagger data remove the data which is not needed and give it to me
//     API url:`;
//     const API_URL_PROMPT_TEMPLATE3 = /* #__PURE__ */ new PromptTemplate({
//         inputVariables: ["api_docs"],
//         template: API_URL_PROMPT_TEMPLATE2,
//       });
//     const apiUrlPrompt = await API_URL_PROMPT_TEMPLATE3.format({
//         api_docs: apiJson,
//       });
    
//      let finalData =  await model.generate([apiUrlPrompt]);
//      console.log(finalData);
//      return finalData
// }
function generateHash(text) {
    return createHash('sha256').update(text).digest('hex');
}

async function splitTextIntoChunks(text) {
    const splitter = new RecursiveCharacterTextSplitter({ chunkSize: 1000, chunkOverlap: 200 });
    const documents = await splitter.createDocuments([text]);
    return documents.map(doc => doc.pageContent);
}

async function generateEmbeddings(textChunks) {
    const embeddings = new OpenAIEmbeddings({ apiKey: process.env.OPENAI_API_KEY });
    const vectors = [];

    for (const chunk of textChunks) {
        const vector = await embeddings.embedQuery(chunk);
        // console.log("Generated Vector:", vector); // Log to check the vector
        if (vector && vector.length > 0) {
            vectors.push({ chunk, vector });
        } else {
            console.error("Invalid or empty vector generated for chunk:", chunk);
        }
    }

    return vectors;
}
async function queryWeaviateForSimilarEmbeddings(questionEmbedding) {
    const searchQuery = {
        vector: {
            and: [
                {
                    property: "vector",  // Assuming the name of the property storing embeddings is "vector"
                    value: {
                        nearVector: {
                            vector: questionEmbedding,
                            limit: 200  // Retrieve top 10 nearest neighbors
                        }
                    }
                }
            ]
        }
    }
    return searchQuery
}

async function main() {
    try {
        const specFilePath = './swagger.json';
        const jsonData = fs.readFileSync(specFilePath, 'utf8');
        console.log("This is json data:", jsonData);
        // const validData = await getValidData(jsonData)
        // console.log("This is valid data", validData)
        // Generate SHA256 hash of JSON data
        const hash = generateHash(jsonData);
        const textChunks = await splitTextIntoChunks(jsonData);
        // console.log("Text chunk", textChunks);
        
        // Generate embeddings for JSON data
        // const dataEmbeddings = await generateEmbeddings(textChunks);
        // console.log("Embeddings", embeddings);
        
        // Initialize Weaviate client
        const client = (weaviate).client({
            scheme: process.env.WEAVIATE_SCHEME || "https",
            host: "swagger-as4wyy7e.weaviate.network",
            apiKey: new ApiKey('yEhKKW4MLmbvVJT2yw7mlTYutuz5zl22U2p1'),
          });

        // Create a store and fill it with some texts + metadata
        await WeaviateStore.fromTexts(
            textChunks,
            textChunks.map(chunk => ({ hash })),
            new OpenAIEmbeddings(),
            {
                client,
                indexName: "Test",
                textKey: "text",
                metadataKeys: ["hash"],
            }
        );
       const query = "Can you give the api url for whitelist investor?"
       let queryEmbedding = await generateEmbeddings(query)
       
       console.log("This is query embedding",queryEmbedding)
        console.log('Embeddings stored successfully.');
       let similarEmbedding = await queryWeaviateForSimilarEmbeddings(queryEmbedding)
       console.log("This is similar embedding",similarEmbedding.vector.length())
        // const result = await client.query(similarEmbedding);   // Trying to get answer
        // console.log("This is the result",result)   // Trying to get answer
        const apiUrlPrompt = await API_URL_PROMPT_TEMPLATE.format({
            api_docs: similarEmbedding,
            question: query,
          });
      
          // console.log("API URL Prompt:", apiUrlPrompt);
      
          const apiUrlResponse = await model.generate([apiUrlPrompt]);
          console.log("API URL Response:", JSON.stringify(apiUrlResponse, null, 2));
      
          // Extract the generated URL from the response
          const apiUrl = apiUrlResponse.generations[0][0]?.text
          console.log("Generated API URL:", apiUrl);
    } catch (error) {
        console.error('Error:', error);
    }
}

main();

Description

In this code I have stored my data in weaviate now I want to fetch the similar embedding I dont know how to query it is not giving similar embedding how to get it so I can send it to openAI

System Info

all good

@dosu · 2024-06-04T12:31:43Z

dosubot[bot]
bot Jun 4, 2024

To properly query Weaviate to retrieve similar embeddings and send them to OpenAI, you can follow these steps:

Create Documents: Define your documents with pageContent and metadata.
Define Attributes: Specify the attributes you want to query.
Instantiate Vector Store: Store the embeddings of the documents.
Create SelfQueryRetriever: Use the retriever to convert natural language queries into Weaviate queries.
Query the Vector Store: Retrieve documents based on your queries.

Here is an example code snippet that demonstrates these steps:

import weaviate, { ApiKey } from "weaviate-ts-client";
import { OpenAIEmbeddings, OpenAI } from "@langchain/openai";
import { SelfQueryRetriever } from "langchain/retrievers/self_query";
import { WeaviateStore, WeaviateTranslator } from "@langchain/weaviate";
import { Document } from "@langchain/core/documents";
import { AttributeInfo } from "langchain/chains/query_constructor";

// Create documents
const docs = [
  new Document({
    pageContent: "A bunch of scientists bring back dinosaurs and mayhem breaks loose",
    metadata: { year: 1993, rating: 7.7, genre: "science fiction" },
  }),
  new Document({
    pageContent: "Leo DiCaprio gets lost in a dream within a dream within a dream within a ...",
    metadata: { year: 2010, director: "Christopher Nolan", rating: 8.2 },
  }),
  new Document({
    pageContent: "A psychologist / detective gets lost in a series of dreams within dreams within dreams and Inception reused the idea",
    metadata: { year: 2006, director: "Satoshi Kon", rating: 8.6 },
  }),
  new Document({
    pageContent: "A bunch of normal-sized women are supremely wholesome and some men pine after them",
    metadata: { year: 9.3, director: "Greta Gerwig", rating: 8.3 },
  }),
  new Document({
    pageContent: "Toys come alive and have a blast doing so",
    metadata: { year: 1995, genre: "animated" },
  }),
  new Document({
    pageContent: "Three men walk into the Zone, three men walk out of the Zone",
    metadata: {
      year: 1979,
      director: "Andrei Tarkovsky",
      genre: "science fiction",
      rating: 9.9,
    },
  }),
];

// Define attributes
const attributeInfo: AttributeInfo[] = [
  { name: "genre", description: "The genre of the movie", type: "string or array of strings" },
  { name: "year", description: "The year the movie was released", type: "number" },
  { name: "director", description: "The director of the movie", type: "string" },
  { name: "rating", description: "The rating of the movie (1-10)", type: "number" },
  { name: "length", description: "The length of the movie in minutes", type: "number" },
];

// Instantiate vector store
const embeddings = new OpenAIEmbeddings();
const llm = new OpenAI({ modelName: "gpt-3.5-turbo" });
const client = (weaviate as any).client({
  scheme: process.env.WEAVIATE_SCHEME || "https",
  host: process.env.WEAVIATE_HOST || "localhost",
  apiKey: new ApiKey(process.env.WEAVIATE_API_KEY || "default"),
});

const vectorStore = await WeaviateStore.fromDocuments(docs, embeddings, {
  client,
  indexName: "Test",
  textKey: "text",
  metadataKeys: ["year", "director", "rating", "genre"],
});

// Create SelfQueryRetriever
const selfQueryRetriever = SelfQueryRetriever.fromLLM({
  llm,
  vectorStore,
  documentContents: "Brief summary of a movie",
  attributeInfo,
  structuredQueryTranslator: new WeaviateTranslator(),
});

// Query the vector store
const query1 = await selfQueryRetriever.getRelevantDocuments("Which movies are rated higher than 8.5?");
const query2 = await selfQueryRetriever.getRelevantDocuments("Which movies are directed by Greta Gerwig?");
console.log(query1, query2);

This code sets up the documents, defines the attributes, initializes the vector store, creates a SelfQueryRetriever, and performs queries to retrieve similar embeddings. The WeaviateStore class provides methods to interact with a Weaviate index, including adding vectors and documents, deleting data, and performing similarity searches ^[1]^[2]^[3]^[4]^[5].

To continue talking to Dosu, mention @dosu.

5 replies

lakshya29154 Jun 4, 2024
Author

No I want to do it for swagger file that I have stored in weaviate I have again made question embedding and need to get nearby embedding

dosubot[bot] bot Jun 4, 2024

To query Weaviate for nearby embeddings of your Swagger file and send them to OpenAI, follow these steps:

Query Weaviate for Nearby Embeddings: Use Weaviate's GraphQL API to query for the nearby embeddings of the Swagger file using the nearVector filter.
Send Embeddings to OpenAI: Use the OpenAIEmbeddings class from the LangChain framework to send the embeddings to OpenAI.

Here is an example code snippet:

Step 1: Query Weaviate for Nearby Embeddings

import weaviate, { ApiKey } from "weaviate-ts-client";
import { WeaviateStore } from "@langchain/weaviate";
import { OpenAIEmbeddings } from "@langchain/openai";

async function getNearbyEmbeddings(swaggerEmbedding: number[]) {
  const client = (weaviate as any).client({
    scheme: process.env.WEAVIATE_SCHEME || "https",
    host: process.env.WEAVIATE_HOST || "localhost",
    apiKey: new ApiKey(process.env.WEAVIATE_API_KEY || "default"),
  });

  const store = await WeaviateStore.fromExistingIndex(new OpenAIEmbeddings(), {
    client,
    indexName: "YourClassName",
    metadataKeys: ["_additional { vector }"],
  });

  const results = await store.similaritySearch(swaggerEmbedding, 10);
  return results.map((item: any) => item.metadata.vector);
}

Step 2: Send Embeddings to OpenAI

import { OpenAIEmbeddings } from "@langchain/openai";

async function sendEmbeddingsToOpenAI(embeddings: number[][]) {
  const openAIEmbeddings = new OpenAIEmbeddings({
    apiKey: 'your-openai-api-key',
  });

  const results = [];
  for (const embedding of embeddings) {
    const result = await openAIEmbeddings.embedQuery(embedding);
    results.push(result);
  }

  return results;
}

// Example usage
(async () => {
  const swaggerEmbedding = [/* your Swagger file embedding */];
  const nearbyEmbeddings = await getNearbyEmbeddings(swaggerEmbedding);
  const openAIResults = await sendEmbeddingsToOpenAI(nearbyEmbeddings);
  console.log(openAIResults);
})();

This code first queries Weaviate to get the nearby embeddings for the Swagger file and then sends those embeddings to OpenAI using the OpenAIEmbeddings class from the LangChain framework. Make sure to replace 'your-openai-api-key' with your actual OpenAI API key and adjust the Weaviate query as needed for your specific schema ^[1]^[2]^[3]^[4].

To continue talking to Dosu, mention @dosu.

lakshya29154 Jun 5, 2024
Author

I have entered this code

import * as fs from "fs";
import { config } from 'dotenv';
import { createHash } from 'crypto';
import { RecursiveCharacterTextSplitter } from "langchain/text_splitter";
import { OpenAIEmbeddings } from "@langchain/openai";
import weaviate, { ApiKey } from "weaviate-ts-client";
import { WeaviateStore } from "@langchain/weaviate";
// import { API_URL_PROMPT_TEMPLATE } from "./test20";
import { OpenAI } from "@langchain/openai";
import { PromptTemplate } from "@langchain/core/prompts";
config();

const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
const model = new OpenAI({ temperature: 0, apiKey: OPENAI_API_KEY });
const API_URL_PROMPT_TEMPLATE1 = `You are given the below the embedding fo some swagger Documentation:
{api_docs}
Using this embeddings, find the relevant API URLs there can be multiple url so give all the url step by step give the method also like get, post , put , delete and give the answer in step1 , step 2 like this.

You should build the API URLs in order to get a response that is as short as possible, while still getting the necessary information to answer the question. Pay attention to deliberately exclude any unnecessary pieces of data in the API call.
Question:{question}
API url:; const API_URL_PROMPT_TEMPLATE = /* #__PURE__ */ new PromptTemplate({ inputVariables: ["api_docs", "question"], template: API_URL_PROMPT_TEMPLATE1, }); // async function getValidData(apiJson) // { // const API_URL_PROMPT_TEMPLATE2 = You are given the below the mebedding fo some swagger json data:
// {api_docs}
// From this json data you have to fetch only those data which are required to recommend the api like its endpoint description method like You will get a question
// like you will get a question give me the api for .... so from the data you need to find the api and give it as response so for now from all the swagger data remove the data which is not needed and give it to me
// API url:`;
// const API_URL_PROMPT_TEMPLATE3 = /* #PURE */ new PromptTemplate({
// inputVariables: ["api_docs"],
// template: API_URL_PROMPT_TEMPLATE2,
// });
// const apiUrlPrompt = await API_URL_PROMPT_TEMPLATE3.format({
// api_docs: apiJson,
// });

// let finalData = await model.generate([apiUrlPrompt]);
// console.log(finalData);
// return finalData
// }
function generateHash(text) {
return createHash('sha256').update(text).digest('hex');
}

async function splitTextIntoChunks(text) {
const splitter = new RecursiveCharacterTextSplitter({ chunkSize: 1000, chunkOverlap: 200 });
const documents = await splitter.createDocuments([text]);
return documents.map(doc => doc.pageContent);
}

async function generateEmbeddings(textChunks) {
const embeddings = new OpenAIEmbeddings({ apiKey: process.env.OPENAI_API_KEY });
const vectors = [];

for (const chunk of textChunks) {
    const vector = await embeddings.embedQuery(chunk);
    // console.log("Generated Vector:", vector); // Log to check the vector
    if (vector && vector.length > 0) {
        vectors.push({ chunk, vector });
    } else {
        console.error("Invalid or empty vector generated for chunk:", chunk);
    }
}

return vectors;

}

async function getNearbyEmbeddings(queryEmbedding) {
const client = (weaviate).client({
scheme: process.env.WEAVIATE_SCHEME || "https",
host: "swagger-as4wyy7e.weaviate.network",
apiKey: new ApiKey('yEhKKW4MLmbvVJT2yw7mlTYutuz5zl22U2p1'),
});

const store = await WeaviateStore.fromExistingIndex(new OpenAIEmbeddings(), {
    client,
    indexName: "Test",
    textKey: "text",
    metadataKeys: ["hash"],
});

const results = await store.similaritySearch(queryEmbedding, 10);
return results.map((item) => item.metadata.vector);

}
async function queryWeaviateForSimilarEmbeddings(questionEmbedding) {
const searchQuery = {
vector: {
and: [
{
property: "vector", // Assuming the name of the property storing embeddings is "vector"
value: {
nearVector: {
vector: questionEmbedding,
limit: 200 // Retrieve top 10 nearest neighbors
}
}
}
]
}
}
return searchQuery
}

async function main() {
try {
const specFilePath = './swagger.json';
const jsonData = fs.readFileSync(specFilePath, 'utf8');
console.log("This is json data:", jsonData);
// const validData = await getValidData(jsonData)
// console.log("This is valid data", validData)
// Generate SHA256 hash of JSON data
const hash = generateHash(jsonData);
const textChunks = await splitTextIntoChunks(jsonData);
// console.log("Text chunk", textChunks);

    // Generate embeddings for JSON data
    // const dataEmbeddings = await generateEmbeddings(textChunks);
    // console.log("Embeddings", embeddings);
    
    // Initialize Weaviate client
    const client = (weaviate).client({
        scheme: process.env.WEAVIATE_SCHEME || "https",
        host: "swagger-as4wyy7e.weaviate.network",
        apiKey: new ApiKey('yEhKKW4MLmbvVJT2yw7mlTYutuz5zl22U2p1'),
      });

    // Create a store and fill it with some texts + metadata
    await WeaviateStore.fromTexts(
        textChunks,
        textChunks.map(chunk => ({ hash })),
        new OpenAIEmbeddings(),
        {
            client,
            indexName: "Test",
            textKey: "text",
            metadataKeys: ["hash"],
        }
    );
   const query = "Can you give the api url for whitelist investor and then fetch all wallet?"
   let queryEmbedding = await generateEmbeddings(query)
   
   console.log("This is query embedding",queryEmbedding)
    console.log('Embeddings stored successfully.');
   let similarEmbedding = await queryWeaviateForSimilarEmbeddings(queryEmbedding)
   console.log("Object inside value:", similarEmbedding.vector.and[0].value.nearVector);
   let similarEmbedding2 =  await getNearbyEmbeddings(queryEmbedding)
   console.log("This is similar embedding",similarEmbedding2)
    // const result = await client.query(similarEmbedding);   // Trying to get answer
    // console.log("This is the result",result)   // Trying to get answer
    const apiUrlPrompt = await API_URL_PROMPT_TEMPLATE.format({
        api_docs: similarEmbedding,
        question: query,
      });
  
      // console.log("API URL Prompt:", apiUrlPrompt);
  
      const apiUrlResponse = await model.generate([apiUrlPrompt]);
      console.log("API URL Response:", JSON.stringify(apiUrlResponse, null, 2));
  
      // Extract the generated URL from the response
      const apiUrl = apiUrlResponse.generations[0][0]?.text
      console.log("Generated API URL:", apiUrl);
} catch (error) {
    console.error('Error:', error);
}

}

main();

But getting this error

Error: TypeError: text.replace is not a function
at OpenAIEmbeddings.embedQuery (file:///C:/Users/LakshyaTambi/Desktop/try/node_modules/@langchain/openai/dist/embeddings.js:219:46)
at WeaviateStore.similaritySearch (file:///C:/Users/LakshyaTambi/Desktop/try/node_modules/@langchain/core/dist/vectorstores.js:104:90)
at getNearbyEmbeddings (file:///C:/Users/LakshyaTambi/Desktop/try/test24.js:86:33)
at process.processTicksAndRejections (node:internal/process/task_queues:95:5)
at async main (file:///C:/Users/LakshyaTambi/Desktop/try/test24.js:150:33)
PS C:\Users\LakshyaTambi\Desktop\try>

dosubot[bot] bot Jun 5, 2024

The error TypeError: text.replace is not a function occurs because the embedQuery method in OpenAIEmbeddings expects a string as input, but it is receiving a different type (likely an array or object). To resolve this, ensure that the input to embedQuery is always a string.

Here is the corrected code with necessary type checks and adjustments:

Ensure queryEmbedding is a string: Modify the generateEmbeddings function to handle string inputs correctly.
Fix getNearbyEmbeddings function: Ensure it receives the correct type of input.

Updated Code

import * as fs from "fs";
import { config } from 'dotenv';
import { createHash } from 'crypto';
import { RecursiveCharacterTextSplitter } from "langchain/text_splitter";
import { OpenAIEmbeddings } from "@langchain/openai";
import weaviate, { ApiKey } from "weaviate-ts-client";
import { WeaviateStore } from "@langchain/weaviate";
import { OpenAI } from "@langchain/openai";
import { PromptTemplate } from "@langchain/core/prompts";
config();

const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
const model = new OpenAI({ temperature: 0, apiKey: OPENAI_API_KEY });
const API_URL_PROMPT_TEMPLATE1 = `You are given the below the embedding fo some swagger Documentation:
{api_docs}
Using this embeddings, find the relevant API URLs there can be multiple url so give all the url step by step give the method also like get, post , put , delete and give the answer in step1 , step 2 like this.

You should build the API URLs in order to get a response that is as short as possible, while still getting the necessary information to answer the question. Pay attention to deliberately exclude any unnecessary pieces of data in the API call.
Question:{question}
API url:`;
const API_URL_PROMPT_TEMPLATE = new PromptTemplate({
    inputVariables: ["api_docs", "question"],
    template: API_URL_PROMPT_TEMPLATE1,
});

function generateHash(text) {
    return createHash('sha256').update(text).digest('hex');
}

async function splitTextIntoChunks(text) {
    const splitter = new RecursiveCharacterTextSplitter({ chunkSize: 1000, chunkOverlap: 200 });
    const documents = await splitter.createDocuments([text]);
    return documents.map(doc => doc.pageContent);
}

async function generateEmbeddings(text) {
    if (typeof text !== 'string') {
        throw new TypeError('Input text must be a string');
    }
    const embeddings = new OpenAIEmbeddings({ apiKey: process.env.OPENAI_API_KEY });
    return await embeddings.embedQuery(text);
}

async function getNearbyEmbeddings(queryEmbedding) {
    const client = (weaviate).client({
        scheme: process.env.WEAVIATE_SCHEME || "https",
        host: "swagger-as4wyy7e.weaviate.network",
        apiKey: new ApiKey('yEhKKW4MLmbvVJT2yw7mlTYutuz5zl22U2p1'),
    });

    const store = await WeaviateStore.fromExistingIndex(new OpenAIEmbeddings(), {
        client,
        indexName: "Test",
        textKey: "text",
        metadataKeys: ["hash"],
    });

    const results = await store.similaritySearch(queryEmbedding, 10);
    return results.map((item) => item.metadata.vector);
}

async function main() {
    try {
        const specFilePath = './swagger.json';
        const jsonData = fs.readFileSync(specFilePath, 'utf8');
        console.log("This is json data:", jsonData);

        const hash = generateHash(jsonData);
        const textChunks = await splitTextIntoChunks(jsonData);

        await WeaviateStore.fromTexts(
            textChunks,
            textChunks.map(chunk => ({ hash })),
            new OpenAIEmbeddings(),
            {
                client,
                indexName: "Test",
                textKey: "text",
                metadataKeys: ["hash"],
            }
        );

        const query = "Can you give the api url for whitelist investor and then fetch all wallet?";
        const queryEmbedding = await generateEmbeddings(query);
        console.log("This is query embedding", queryEmbedding);

        const similarEmbeddings = await getNearbyEmbeddings(queryEmbedding);
        console.log("This is similar embedding", similarEmbeddings);

        const apiUrlPrompt = await API_URL_PROMPT_TEMPLATE.format({
            api_docs: similarEmbeddings,
            question: query,
        });

        const apiUrlResponse = await model.generate([apiUrlPrompt]);
        console.log("API URL Response:", JSON.stringify(apiUrlResponse, null, 2));

        const apiUrl = apiUrlResponse.generations[0][0]?.text;
        console.log("Generated API URL:", apiUrl);
    } catch (error) {
        console.error('Error:', error);
    }
}

main();

Key Changes:

Type Check in generateEmbeddings: Ensures the input is a string.
Corrected getNearbyEmbeddings: Ensures it processes the embeddings correctly.

This should resolve the TypeError: text.replace is not a function error and allow you to query Weaviate for similar embeddings and send them to OpenAI ^[1]^[2]^[3].

To continue talking to Dosu, mention @dosu.

lakshya29154 Jun 5, 2024
Author

OK so in getNearByEmbedding we need to pass only query it will automatically convert in embedding and then find the reultant near embedding

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

WeAviate fetch similar vector #5656

Uh oh!

{{title}}

Uh oh!

Replies: 1 comment 5 replies

Uh oh!

{{title}}

Uh oh!

Uh oh!

{{title}}

Uh oh!

Uh oh!

{{title}}

Uh oh!

Uh oh!

{{title}}

Uh oh!

Uh oh!

{{title}}

Uh oh!

Uh oh!

{{title}}

Uh oh!

Select a reply

Uh oh!

WeAviate fetch similar vector #5656

Uh oh!

lakshya29154 Jun 4, 2024

Checked other resources

Commit to Help

Example Code

Description

System Info

Replies: 1 comment · 5 replies

Uh oh!

dosubot[bot] bot Jun 4, 2024

Uh oh!

lakshya29154 Jun 4, 2024 Author

Uh oh!

dosubot[bot] bot Jun 4, 2024

Step 1: Query Weaviate for Nearby Embeddings

Step 2: Send Embeddings to OpenAI

Uh oh!

lakshya29154 Jun 5, 2024 Author

Uh oh!

dosubot[bot] bot Jun 5, 2024

Updated Code

Key Changes:

Uh oh!

lakshya29154 Jun 5, 2024 Author

lakshya29154
Jun 4, 2024

Replies: 1 comment 5 replies

dosubot[bot]
bot Jun 4, 2024

lakshya29154 Jun 4, 2024
Author

lakshya29154 Jun 5, 2024
Author

lakshya29154 Jun 5, 2024
Author