Feature request: Return the api_response in APIChain.from_llm_and_api_docs _call

[MatteoCarlone]

Checked

• I searched existing ideas and did not find a similar one
• I added a very descriptive title
• I've clearly described the feature request and motivation for it

Feature request

While using APIChain to make our llm interact with APIs we faced the need to get the as return value the actual api response retrived by the LLM while reasoning.

We simply fixed by adding the the return in the _call method here

def _call(
        self,
        inputs: Dict[str, Any],
        run_manager: Optional[CallbackManagerForChainRun] = None,
    ) -> Dict[str, str]:
        _run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
        question = inputs[self.question_key]
        api_url = self.api_request_chain.predict(
            question=question,
            api_docs=self.api_docs,
            callbacks=_run_manager.get_child(),
        )
        _run_manager.on_text(api_url, color="green", end="\n", verbose=self.verbose)
        api_url = api_url.strip()
        if self.limit_to_domains and not _check_in_allowed_domain(
            api_url, self.limit_to_domains
        ):
            raise ValueError(
                f"{api_url} is not in the allowed domains: {self.limit_to_domains}"
            )
        api_response = self.requests_wrapper.get(api_url)
        _run_manager.on_text(
            str(api_response), color="yellow", end="\n", verbose=self.verbose
        )
        answer = self.api_answer_chain.predict(
            question=question,
            api_docs=self.api_docs,
            api_url=api_url,
            api_response=api_response,
            callbacks=_run_manager.get_child(),
        )
        return {self.output_key: [answer, api_response]}
        

and used it as:

api = APIChain.from_llm_and_api_docs(
    llm,
    json.dumps(api_functions),
    verbose=True,
    api_url_prompt=API_URL_PROMPT,
    api_response_prompt= API_RESPONSE_PROMPT,
    limit_to_domains=["http://127.0.0.1:5000"],
)

.......

 # Call the api instance
    result = api({"question": input_text})

# Access the answer and the API response from the result dict
output_string, api_response = result["output"]

The feature we want to propose is just adding the possibility get the the api payload when needed.

Motivation

The motivation for my request is precisely the need that I have encountered and that many other langchain users may encounter, namely the ability to get the api payload for more sophisticated logic in our code that goes beyond just using llm.

Proposal (If applicable)

Add a return to the _call and _acall method in the APIChain class here