How to send question and get all relevant answer in json

[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 { PDFLoader } from "@langchain/community/document_loader/fs/pdf";
import { OpenAIEmbeddings } from "@langchain/openai";
import { OpenAI } from "@langchain/openai";
import { OpenAIChat } from "@langchain/openai";
import { PromptTemplate } from "@langchain/core/prompts";
import { Client } from "@opensearch-project/opensearch";
import { PDFLoader } from "langchain/document_loaders/fs/pdf";

config();


const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
const model = new OpenAI({ temperature: 0.1, ap5iKey: OPENAI_API_KEY });

const client = new Client({
  node: "http://localhost:9200",
});

client
  .info()
  .then((response) => console.log("Elasticsearch Cluster Info:", response))
  .catch((error) => console.error("Error connecting to Elasticsearch:", error));

const INDEX_NAME = "privateequityfile2";

// Function to create an index with mappings and settings
async function createIndex() {
  const indexBody = {
    settings: {
      number_of_shards: 1,
      number_of_replicas: 0,
    },
    mappings: {
      properties: {
        content: { type: "text" },
        embedding: { type: "dense_vector", dims: 1536 },
        pdfHash: { type: "keyword" },
      },
    },
  };

  try {
    const indexExists = await client.indices.exists({ index: INDEX_NAME });
    if (!indexExists.body) {
      const response = await client.indices.create({
        index: INDEX_NAME,
        body: indexBody,
      });
      console.log("Index created:", response);
    } else {
      console.log("Index already exists.");
    }
  } catch (error) {
    console.error("Error creating index:", error);
  }
}

function generateHash(text) {
  let texts = text.toString();
  return createHash("sha256").update(texts).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) {
    console.log("Chunks",chunk)
    const vector = await embeddings.embedQuery(chunk);
    if (vector && vector.length > 0) {
      vectors.push({ chunk, vector });
    } else {
      console.error("Invalid or empty vector generated for chunk:", chunk);
    }
  }
  return vectors;
}

async function storeInOpenSearch(vectors, pdfHash) {
  for (const item of vectors) {
    if (!item.vector || item.vector.length === 0) {
      console.error("Invalid or empty vector data:", item);
      continue;
    }

    try {
      await client.index({
        index: INDEX_NAME,
        body: {
          content: item.chunk,
          embedding: item.vector,
          pdfHash: pdfHash,
        },
      });
    } catch (error) {
      console.error("Error storing data in Elasticsearch:", error);
      throw error;
    }
  }
}

async function checkProcessed(pdfHash) {
  try {
    const { body } = await client.search({
      index: INDEX_NAME,
      body: {
        size: 1,
        query: {
          match: { pdfHash: pdfHash },
        },
      },
    });

    return body.hits.total.value > 0;
  } catch (error) {
    console.error("Error checking if PDF is processed:", error);
    throw error;
  }
}

async function queryOpenSearch(queryVector, topK = 10) {
  try {
    const { body } = await client.search({
      index: INDEX_NAME,
      body: {
        size: topK,
        query: {
          script_score: {
            query: { match_all: {} },
            script: {
              source:
                "cosineSimilarity(params.query_vector, doc['embedding']) + 1.0",
              params: { query_vector: queryVector },
            },
          },
        },
      },
    });

    return body.hits.hits.map((hit) => ({
      chunk: hit._source.content,
      distance: 1 - hit._score, // Adjust score calculation if needed
    }));
  } catch (error) {
    console.error(
      "Error querying Elasticsearch:",
      error.meta.body.error.root_cause[0].reason
    );
    throw error;
  }
}

async function askOpenAI(question, context) {
  const chat = new OpenAIChat({
    apiKey: process.env.OPENAI_API_KEY,
    modelName: "gpt-4",
    temperature: 0.7,
  });

  const prompt = `${context}\n\nQuestion: ${question}`;
  try {
    const answer = await chat.call(prompt);
    return answer.trim();
  } catch (error) {
    console.error("Error querying OpenAI:", error);
    return "Error querying OpenAI";
  }
}

// temp add

const API_URL_PROMPT_TEMPLATE1 = `
You are an expert JSON formatter. I will provide you with a set of questions and corresponding data. 
Your task is to format the answers into valid JSON by following the given key-value structure. 
For each question, use the data provided to populate the appropriate values in the JSON format.

- Here are your questions: {question}
- Here is your data: {api_docs}

Please generate the output in the following JSON format:

{{
    "fund_size": "string",
    "fund_manager": "string",
    "fund_life_rate": "string",
    "management_fee": "string",
    "investment_period": "string",
    "minimum_commitment": "string",
    "maximum_commitment": "string",
    "fixed_interest_rate": "string",
    "general_partner_catch_up": "string"
}}

Make sure to:
- Accurately map the data to each corresponding key.
- Ensure the JSON structure is valid and properly formatted.
- Only use the provided data to populate the values.
`

  const API_URL_PROMPT_TEMPLATE = new PromptTemplate({
    inputVariables: ["api_docs", "question"],
    template: API_URL_PROMPT_TEMPLATE1,
  });

// end

export async function main1(filePath) {
  const specFilePath = filePath;
  const loader = new PDFLoader(specFilePath, {
    parsedItemSeparator: "",
  });
  const docs = await loader.load();
  //  console.log("This is docs",docs)
  // const jsonData = fs.readFileSync(specFilePath, "utf8");
  // const swaggerData = docs
  let hash = generateHash(docs);
  
  // Create the index if it doesn't exist
  await createIndex();

  const isProcessed = await checkProcessed(hash);
  if (isProcessed) {
    console.log(
      // "JSON has already been processed. Skipping embedding generation."
    );
  } else {
    const swaggerData1 = JSON.stringify(docs);
    const textChunks = await splitTextIntoChunks(swaggerData1);
    // console.log("Text chunks generated:", textChunks);

    const vectors = await generateEmbeddings(textChunks);
    // console.log("Embeddings generated:", vectors , typeof(vectors));
    await storeInOpenSearch(vectors,hash);
  }
  let question1 = ["What would be the minimum and maximum commitments?",
    "Who would be the fund manager?",
    "What would be the life of fund?",
    " What would be the management fees?",
    "What would be the investment period extension?",
    "What would be the minimum commitment?",
    "What would be the maximum commitment?",
    "What is the preferred fixed interest rate return?",
    "What is the General Partner CatchUp?"]

    question1 = question1.toString();
  const embeddings = new OpenAIEmbeddings({
    apiKey: process.env.OPENAI_API_KEY,
  });
  const queryVector = await embeddings.embedQuery(question1);

  const relevantChunks = await queryOpenSearch(queryVector);
  console.log("Relevant chunks:", relevantChunks);
  const context = relevantChunks.map((result) => result.chunk).join("\n\n");
  console.log("Context:", context);

  //approch 2
  const apiUrlPrompt = await API_URL_PROMPT_TEMPLATE.format({
    api_docs: context,
    question: question1,
  });
  const apiUrlResponse = await model.generate([apiUrlPrompt]);
  console.log("API URL Response:", JSON.stringify(apiUrlResponse, null, 1));
  console.log(apiUrlResponse.generations[0][0]);
  const apiUrl = apiUrlResponse.generations[0][0]?.text;
  console.log("Generated API URL:", apiUrlResponse.generations[0][0]?.text , "\n");
  // return apiUrl;
}

main1("OfferingData/private_equity_large1.pdf")  // Also

Description

I want to make a script where I can send multiple question at once and I get answer in json format . I tried this but when i earlies send single question it give me correct answer now If i send all question it doesnt get me correct answer might need to go with different approach or anything can you help so i get accurate answer and in json format

System Info

node verson - 20
paltform - windows

[dosubot[bot]]

To send multiple questions at once and receive accurate answers in JSON format using LangChain and OpenAI, you can modify your script to process multiple inputs simultaneously. Here's a streamlined approach:

1. Batch Processing: Use the batch method to handle multiple questions at once.

2. Prompt Template: Ensure your prompt template is correctly set up to handle multiple questions and format the output as JSON.

Here's an example of how you can achieve this:

import { ChatOpenAI } from "@langchain/openai";
import { PromptTemplate } from "@langchain/core/prompts";

async function processQuestions(questions: string[]): Promise<any> {
  const model = new ChatOpenAI({ apiKey: process.env.OPENAI_API_KEY });
  const promptTemplate = new PromptTemplate({
    inputVariables: ["questions", "context"],
    template: `
      You are an expert JSON formatter. For each question, use the context provided to populate the appropriate values in the JSON format.

      Questions: {questions}
      Context: {context}

      Please generate the output in the following JSON format:
      [
        {
          "fund_size": "string",
          "fund_manager": "string",
          "fund_life_rate": "string",
          "management_fee": "string",
          "investment_period": "string",
          "minimum_commitment": "string",
          "maximum_commitment": "string",
          "fixed_interest_rate": "string",
          "general_partner_catch_up": "string"
        }
      ]
    `,
  });

  const inputs = questions.map((question) => ({ questions: question, context: "Your context here" }));
  const results = await model.batch(inputs);

  return JSON.stringify(
    results.map((result, index) => ({
      question: questions[index],
      answer: result.content,
    }))
  );
}

// Example usage
const questions = [
  "What would be the minimum and maximum commitments?",
  "Who would be the fund manager?",
  "What would be the life of fund?",
  "What would be the management fees?",
  "What would be the investment period extension?",
  "What would be the minimum commitment?",
  "What would be the maximum commitment?",
  "What is the preferred fixed interest rate return?",
  "What is the General Partner CatchUp?"
];

processQuestions(questions).then((jsonResults) => {
  console.log(jsonResults);
});

Key Points:

• Batch Method: This allows you to process multiple questions efficiently.
• Prompt Template: Ensure your template is structured to handle multiple questions and format the output as JSON.
• Context: Make sure to provide the necessary context for each question to get accurate answers.

This approach should help you get accurate answers in JSON format for multiple questions ^[1].

To continue talking to Dosu, mention @dosu.

[lakshya29154]

Can you give complete script

[lakshya29154]

??

[lakshya29154]

Can you give me complete script