Hitting api

[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 { createOpenAPIChain } from "langchain/chains";
import { OpenAI } from "@langchain/openai";
import { config } from "dotenv";
import { StringOutputParser } from "@langchain/core/output_parsers";
import { PromptTemplate } from "@langchain/core/prompts";
config();

const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
const model = new OpenAI({ modelName: 'gpt-4', temperature: 0, apiKey: OPENAI_API_KEY });

const endpointFinderModel = new OpenAI({ modelName: 'gpt-4', temperature: 0, apiKey: OPENAI_API_KEY });
const prompt1 = PromptTemplate.fromTemplate("You are now swagger assistant. You have to read the {swagger} file and then answer the question: {query}");
const chain = await createOpenAPIChain("https://petstore.swagger.io/v2/swagger.json", {
  llm: model,
  endpointFinderModel: endpointFinderModel,
//   prompt:prompt1,
  outputParser: new StringOutputParser(),
});
 
const query = "Can you give me the API complete url to Return Pet inventories by status?";
const swagger = "https://petstore.swagger.io/v2/swagger.json"
const result = await chain.invoke({ query: "Can you give me the API to update the existing pet?", swagger: "https://petstore.swagger.io/v2/swagger.json" });
console.log(result);

Description

Can someone help me I want to make a script that takes the url of swagger and query of user based on the query it will find the best suitable api and automatically hit the api if it require anything this will be given in prompt like any body needed for api but how can I do this

System Info

I am using langchain 0.1 documentation

[dosubot[bot]]

Hey @lakshya29154! 👋 I'm here to help you with bugs, questions, and becoming a contributor. Let's squash those bugs together!

To create a script that takes a Swagger URL and a user query, finds the best suitable API, and automatically hits the API, you can use the OpenApiToolkit and createOpenApiAgent functions. Here's how you can modify your script to achieve this:

1. Import necessary modules and functions.
2. Create a function that initializes the OpenAPI agent with the given Swagger URL and user query.
3. Execute the agent to get the response.

Here is the modified script:

import * as fs from "fs";
import * as yaml from "js-yaml";
import { JsonSpec, JsonObject } from "langchain/tools";
import { createOpenApiAgent, OpenApiToolkit } from "langchain/agents";
import { OpenAI } from "@langchain/openai";
import { API_URL_PROMPT_TEMPLATE, API_RESPONSE_PROMPT_TEMPLATE } from "langchain/src/chains/api/prompts";
import { config } from "dotenv";
config();

const OPENAI_API_KEY = process.env.OPENAI_API_KEY;

/**
 * Function to create and execute an OpenAPI agent based on a Swagger URL and user query.
 * @param swaggerUrl The URL of the Swagger specification.
 * @param userQuery The user query to find the best suitable API.
 * @returns The response from the API.
 */
async function executeOpenApiAgent(swaggerUrl: string, userQuery: string) {
  try {
    // Load the OpenAPI specification from the Swagger URL
    const response = await fetch(swaggerUrl);
    const data = await response.json() as JsonObject;

    if (!data) {
      throw new Error("Failed to load OpenAPI spec");
    }

    // Initialize the language model
    const model = new OpenAI({ temperature: 0, apiKey: OPENAI_API_KEY });

    // Create the OpenAPI toolkit
    const headers = {
      "Content-Type": "application/json",
      Authorization: `Bearer ${OPENAI_API_KEY}`,
    };
    const toolkit = new OpenApiToolkit(new JsonSpec(data), model, headers);

    // Create the OpenAPI agent
    const executor = createOpenApiAgent(model, toolkit);

    // Generate the API URL using the prompt template
    const apiUrlPrompt = API_URL_PROMPT_TEMPLATE.format({
      api_docs: JSON.stringify(data),
      question: userQuery,
    });
    const apiUrlResponse = await model.generate(apiUrlPrompt);
    const apiUrl = apiUrlResponse.text.trim();

    // Execute the API call
    const apiResponse = await fetch(apiUrl, { headers });
    const apiResponseData = await apiResponse.json();

    // Summarize the API response using the prompt template
    const apiResponsePrompt = API_RESPONSE_PROMPT_TEMPLATE.format({
      api_docs: JSON.stringify(data),
      question: userQuery,
      api_url: apiUrl,
      api_response: JSON.stringify(apiResponseData),
    });
    const summaryResponse = await model.generate(apiResponsePrompt);
    const summary = summaryResponse.text.trim();

    // Return the summarized response
    return summary;
  } catch (error) {
    console.error('Error executing OpenAPI agent:', error);
    throw error;
  }
}

// Example usage
const swaggerUrl = 'https://petstore.swagger.io/v2/swagger.json';
const userQuery = 'Can you give me the API complete url to Return Pet inventories by status?';
executeOpenApiAgent(swaggerUrl, userQuery)
  .then(response => console.log('API Response:', response))
  .catch(error => console.error('Error:', error));

This script initializes the OpenAPI agent with the provided Swagger URL and user query, then executes the agent to get the response from the best suitable API. The OpenApiToolkit and createOpenApiAgent functions handle the conversion of the OpenAPI specification and the execution of the API request. The PromptTemplate from langchain/src/chains/api/prompts.ts is used to generate the API URL and summarize the API response ^[1][2][3][4].

Details

About Dosu
This response is meant to be useful and save you time. It is not meant to be a precise solution, but rather a starting point for your own research.

Help me be more useful! Please leave a 👍 if this is helpful and 👎 if it is irrelevant.

To continue the conversation, mention @dosu.

[lakshya29154]

Error executing OpenAPI agent: Error: Argument 'prompts' is expected to be a string[]
at OpenAI.generate (file:///C:/Users/LakshyaTambi/Desktop/try/node_modules/@langchain/core/dist/language_models/llms.js:216:19)
at executeOpenApiAgent (file:///C:/Users/LakshyaTambi/Desktop/try/test19.js:46:40)
at process.processTicksAndRejections (node:internal/process/task_queues:95:5)
Error: Error: Argument 'prompts' is expected to be a string[]
at OpenAI.generate (file:///C:/Users/LakshyaTambi/Desktop/try/node_modules/@langchain/core/dist/language_models/llms.js:216:19)
at executeOpenApiAgent (file:///C:/Users/LakshyaTambi/Desktop/try/test19.js:46:40)
at process.processTicksAndRejections (node:internal/process/task_queues:95:5)
PS C:\Users\LakshyaTambi\Desktop\try>

[lakshya29154]

I might think there is a issue of prompt let me show you

import * as fs from "fs";
import * as yaml from "js-yaml";
import { JsonSpec } from "langchain/tools";
import { createOpenApiAgent, OpenApiToolkit } from "langchain/agents";
import { OpenAI } from "@langchain/openai";
import { API_URL_PROMPT_TEMPLATE, API_RESPONSE_PROMPT_TEMPLATE } from "./test20.js";
import { config } from "dotenv";
config();

const OPENAI_API_KEY = process.env.OPENAI_API_KEY;

/**

• Function to create and execute an OpenAPI agent based on a Swagger URL and user query.

• @param swaggerUrl The URL of the Swagger specification.

• @param userQuery The user query to find the best suitable API.

• @returns The response from the API.
  */
  async function executeOpenApiAgent(swaggerUrl, userQuery) {
  try {
  // Load the OpenAPI specification from the Swagger URL
  const response = await fetch(swaggerUrl);
  const data = await response.json();

  if (!data) {
  throw new Error("Failed to load OpenAPI spec");
  }

  // Initialize the language model
  const model = new OpenAI({ temperature: 0, apiKey: OPENAI_API_KEY });

  // Create the OpenAPI toolkit
  const headers = {
  "Content-Type": "application/json",
  Authorization: Bearer ${OPENAI_API_KEY},
  };
  const toolkit = new OpenApiToolkit(new JsonSpec(data), model, headers);

  // Create the OpenAPI agent
  const executor = createOpenApiAgent(model, toolkit);

  // Generate the API URL using the prompt template
  const apiUrlPrompt = API_URL_PROMPT_TEMPLATE.format({
  api_docs: JSON.stringify(data),
  question: userQuery,
  });
  const apiUrlResponse = await model.generate(apiUrlPrompt);
  const apiUrl = apiUrlResponse.text.trim();

  // Execute the API call
  const apiResponse = await fetch(apiUrl, { headers });
  const apiResponseData = await apiResponse.json();

  // Summarize the API response using the prompt template
  const apiResponsePrompt = API_RESPONSE_PROMPT_TEMPLATE.format({
  api_docs: JSON.stringify(data),
  question: userQuery,
  api_url: apiUrl,
  api_response: JSON.stringify(apiResponseData),
  });
  const summaryResponse = await model.generate(apiResponsePrompt);
  const summary = summaryResponse.text.trim();

  // Return the summarized response
  return summary;
  } catch (error) {
  console.error('Error executing OpenAPI agent:', error);
  throw error;
  }
  }

// Example usage
const swaggerUrl = 'https://petstore.swagger.io/v2/swagger.json';
const userQuery = 'Can you give me the API complete url to Return Pet inventories by status?';
executeOpenApiAgent(swaggerUrl, userQuery)
.then(response => console.log('API Response:', response))
.catch(error => console.error('Error:', error));

-----------------------------------------------------------------This is the script ------------------------------------------------------------

/* eslint-disable spaced-comment */
import { PromptTemplate } from "@langchain/core/prompts";

export const API_URL_RAW_PROMPT_TEMPLATE = `You are given the below API Documentation:
{api_docs}
Using this documentation, generate the full API url to call for answering the user question.
You should build the API url 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:`;

export const API_URL_PROMPT_TEMPLATE = /* #PURE */ new PromptTemplate({
inputVariables: ["api_docs", "question"],
template: API_URL_RAW_PROMPT_TEMPLATE,
});

export const API_RESPONSE_RAW_PROMPT_TEMPLATE = `${API_URL_RAW_PROMPT_TEMPLATE} {api_url}

Here is the response from the API:

{api_response}

Summarize this response to answer the original question.

Summary:`;
export const API_RESPONSE_PROMPT_TEMPLATE = /* #PURE */ new PromptTemplate({
inputVariables: ["api_docs", "question", "api_url", "api_response"],
template: API_RESPONSE_RAW_PROMPT_TEMPLATE,
});

--------------------------------------------------This is the prompt script----------------------------------------------------------------------

[lakshya29154]

Also how to send payload and params

[dosubot[bot]]

The error you're encountering is because the generate method of the OpenAI class expects the prompts argument to be an array of strings, but it seems you're passing a single string instead. You need to wrap the prompt in an array.

Here's how you can fix the script:

1. Wrap the prompt in an array when calling the generate method.
2. Modify the script to send payload and params with the API request.

Here is the updated script:

import * as fs from "fs";
import * as yaml from "js-yaml";
import { JsonSpec } from "langchain/tools";
import { createOpenApiAgent, OpenApiToolkit } from "langchain/agents";
import { OpenAI } from "@langchain/openai";
import { API_URL_PROMPT_TEMPLATE, API_RESPONSE_PROMPT_TEMPLATE } from "./test20.js";
import { config } from "dotenv";
config();

const OPENAI_API_KEY = process.env.OPENAI_API_KEY;

/**
 * Function to create and execute an OpenAPI agent based on a Swagger URL and user query.
 * @param swaggerUrl The URL of the Swagger specification.
 * @param userQuery The user query to find the best suitable API.
 * @returns The response from the API.
 */
async function executeOpenApiAgent(swaggerUrl, userQuery) {
  try {
    // Load the OpenAPI specification from the Swagger URL
    const response = await fetch(swaggerUrl);
    const data = await response.json();

    if (!data) {
      throw new Error("Failed to load OpenAPI spec");
    }

    // Initialize the language model
    const model = new OpenAI({ temperature: 0, apiKey: OPENAI_API_KEY });

    // Create the OpenAPI toolkit
    const headers = {
      "Content-Type": "application/json",
      Authorization: `Bearer ${OPENAI_API_KEY}`,
    };
    const toolkit = new OpenApiToolkit(new JsonSpec(data), model, headers);

    // Create the OpenAPI agent
    const executor = createOpenApiAgent(model, toolkit);

    // Generate the API URL using the prompt template
    const apiUrlPrompt = API_URL_PROMPT_TEMPLATE.format({
      api_docs: JSON.stringify(data),
      question: userQuery,
    });
    const apiUrlResponse = await model.generate([apiUrlPrompt]); // Wrap the prompt in an array
    const apiUrl = apiUrlResponse.text.trim();

    // Execute the API call
    const apiResponse = await fetch(apiUrl, { headers });
    const apiResponseData = await apiResponse.json();

    // Summarize the API response using the prompt template
    const apiResponsePrompt = API_RESPONSE_PROMPT_TEMPLATE.format({
      api_docs: JSON.stringify(data),
      question: userQuery,
      api_url: apiUrl,
      api_response: JSON.stringify(apiResponseData),
    });
    const summaryResponse = await model.generate([apiResponsePrompt]); // Wrap the prompt in an array
    const summary = summaryResponse.text.trim();

    // Return the summarized response
    return summary;
  } catch (error) {
    console.error('Error executing OpenAPI agent:', error);
    throw error;
  }
}

// Example usage
const swaggerUrl = 'https://petstore.swagger.io/v2/swagger.json';
const userQuery = 'Can you give me the API complete url to Return Pet inventories by status?';
executeOpenApiAgent(swaggerUrl, userQuery)
  .then(response => console.log('API Response:', response))
  .catch(error => console.error('Error:', error));

To send payload and params with the API request, you can modify the fetch call to include the necessary options:

// Execute the API call with payload and params
const apiResponse = await fetch(apiUrl, {
  method: 'POST', // or 'GET', 'PUT', etc.
  headers,
  body: JSON.stringify({ key1: 'value1', key2: 'value2' }), // Example payload
});

This should resolve the issue and allow you to send payload and params with the API request.

To continue talking to Dosu, mention @dosu.