Trouble with Asynchronous API Calls

[peterjacksonwonka]

I'm trying to make multiple API calls simultaneously,
but it seems like each call waits for the previous one to finish before starting,
even when I set the async option to false.
It seems like the asynchronous calls are not working properly.
I initiated the calls by creating a flow and then calling the API with the endpoint /api/v1/process/{flowId}.
The API I tested involves a flow.
It loads documents using a loader component, stores them in Chroma db component, and then retrieves them.
I get the same results when testing with a flow that only includes chatopenai component.
How can I properly implement asynchronous behavior for these API calls?

[dosubot[bot]]

Hey @peterjacksonwonka! Nice to see you back in the world of async adventures 🌀

Based on your description, it seems like you're trying to make multiple API calls concurrently, but they're executing sequentially. This behavior can occur if the promises representing the API calls are not being handled correctly.

In JavaScript, you can use Promise.all or Promise.allSettled to handle multiple promises concurrently. These functions return a single promise that fulfills when all of the passed promises have either fulfilled (Promise.all) or settled (Promise.allSettled).

Here's an example of how you might implement this in your code:

import { api } from "../../controllers/API/api";

async function processFlow(flowId: string) {
  return await api.get(`/api/v1/process/${flowId}`);
}

async function processFlowsParallel(flowIds: string[]) {
  const promises = flowIds.map(flowId => processFlow(flowId));
  return await Promise.all(promises);
}

const flowIds = ['flowId1', 'flowId2', 'flowId3']; // Replace these with actual flow IDs
processFlowsParallel(flowIds)
  .then(responses => {
    console.log('All flows processed:', responses);
  })
  .catch(error => {
    console.error('Error processing flows:', error);
  });

In this example, processFlow is a function that takes a flowId and returns a promise for calling the /api/v1/process/{flow_id} endpoint. processFlowsParallel takes an array of flowIds, maps them to an array of promises using processFlow, and then uses Promise.all to execute them in parallel. This approach should work assuming your API and server infrastructure can handle the concurrent load.

This solution was suggested in a similar open issue How use async APIs ? in the Langflow repository.

Please note that Promise.all rejects as soon as one of the promises in the array rejects. If you want to wait for all promises to settle regardless of whether they resolve or reject, you can use Promise.allSettled instead.

I hope this helps! If you have any other questions or need further clarification, feel free to ask.

Sources

• How use async APIs ?
• src/frontend/src/controllers/API/index.ts

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.

If you want to continue the conversation, start your reply with @dosu-bot.

[Cristhianzl]

Hi! 👋

We are using other channels as our official means of communication with users. We apologize for the delayed response.
For faster assistance, please direct your questions to our Discord channel or open a GitHub issue, as we are much more active on these platforms.

Langflow Discord Server

Thank you for your understanding.

Best regards,
The Langflow Team