text.replace function

[lakshya29154]

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 { 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);
    // console.log("This is the result", results);
    // 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);
        const client = (weaviate).client({
            scheme: process.env.WEAVIATE_SCHEME || "https",
            host: "swagger-as4wyy7e.weaviate.network",
            apiKey: new ApiKey('yEhKKW4MLmbvVJT2yw7mlTYutuz5zl22U2p1'),
        });
        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();

Description

I am getting 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/test27.js:58:33)
at process.processTicksAndRejections (node:internal/process/task_queues:95:5)
at async main (file:///C:/Users/LakshyaTambi/Desktop/try/test27.js:92:35)

System Info

ok

[dosubot[bot]]

The error TypeError: text.replace is not a function occurs because the embedQuery function in the OpenAIEmbeddings class expects a string as input. Ensure that the text parameter passed to embedQuery is always a string.

Here's how you can fix it:

1. Check the input type: Ensure that the text argument is a string before calling embedQuery.

2. Add a type check: Add a type check in the generateEmbeddings function to throw an error if the input is not a string.

Here's the updated generateEmbeddings function:

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);
}

Additionally, ensure that the queryEmbedding passed to getNearbyEmbeddings is correctly formatted and of the expected type.

Here's the relevant part of your code with the necessary checks:

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);
        const client = (weaviate).client({
            scheme: process.env.WEAVIATE_SCHEME || "https",
            host: "swagger-as4wyy7e.weaviate.network",
            apiKey: new ApiKey('yEhKKW4MLmbvVJT2yw7mlTYutuz5zl22U2p1'),
        });
        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();

This should resolve the TypeError: text.replace is not a function error by ensuring that the input to embedQuery is always a string ^[1][2].

To continue talking to Dosu, mention @dosu.