How to I pass a body for API chain if the body is an array?

[Nidhipriya8]

I am using -
chain = OpenAPIEndpointChain.from_api_operation(
operation,
llm,
Requests(),

verbose=True,
return_intermediate_steps=True  # Return request and response text

)
print("Chain is ", chain)

output = chain(f"What is the API response for text =grey")
and I want to hit the API with following body
[{'text': 'gandhi'}]
Following are the intermediate_steps i get -
OutPut: {'instructions': 'What is the API resposne? for text =grey', 'output': 'The API could not understand the request you sent. It returned a 400 Bad Request error. Please make sure to provide the correct parameters for your request and try again.', 'intermediate_steps': {'request_args': '{"body": ["grey"], "x-correlation-id": "", "accept-language": "en"}', 'response_text': '400: Bad Request\nFor POST https://translation-pp.monotype.com/translation/v2\nCalled with args: {}'}}
{'request_args': '{"body": ["grey"], "x-correlation-id": "", "accept-language": "en"}', 'response_text': '400: Bad Request\nFor POST https://translation-pp.monotype.com/translation/v2\nCalled with args: {}'}
API Response 400: Bad Request

This indicates wrong body sent.
Also, If I send output = chain(f"What is the API response for [{"text" ="grey"}])

Then 'request_args': '{"body": [{"text": "gandhi"}], "x-correlation-id": "", "accept-language": "en"}'

[dosubot[bot]]

🤖

Hello,

From your description, it seems like you're trying to pass an array as the body of your API request. The OpenAPIEndpointChain.from_api_operation method in LangChain handles the body parameter by creating a _ParamMapping instance, which includes body_params among its attributes. This _ParamMapping instance is then used to initialize an OpenAPIEndpointChain instance.

The body_params attribute of the _ParamMapping instance is populated with the body_params attribute of the APIOperation instance passed to the from_api_operation method.

The body_params are then used in the _extract_body_params method of the OpenAPIEndpointChain class. This method extracts the request body parameters from the deserialized input. If there are any body_params, it creates a dictionary where each key-value pair corresponds to a body parameter and its value.

Here is the relevant code:

@classmethod
def from_api_operation(
    cls,
    operation: APIOperation,
    llm: BaseLanguageModel,
    requests: Optional[Requests] = None,
    verbose: bool = False,
    return_intermediate_steps: bool = False,
    raw_response: bool = False,
    callbacks: Callbacks = None,
    **kwargs: Any
    # TODO: Handle async
) -> "OpenAPIEndpointChain":
    """Create an OpenAPIEndpointChain from an operation and a spec."""
    param_mapping = _ParamMapping(
        query_params=operation.query_params,
        body_params=operation.body_params,
        path_params=operation.path_params,
    )
    ...
    return cls(
        ...
        param_mapping=param_mapping,
        ...
    )

def _extract_body_params(self, args: Dict[str, str]) -> Optional[Dict[str, str]]:
    """Extract the request body params from the deserialized input."""
    body_params = None
    if self.param_mapping.body_params:
        body_params = {}
        for param in self.param_mapping.body_params:
            if param in args:
                body_params[param] = args.pop(param)
    return body_params

This method does not differentiate between single values and arrays. If a body parameter is an array, it will be included in the body_params dictionary as an array.

In your case, you should be able to pass the array as the body parameter like this:

output = chain(f"What is the API response for text = [{'text': 'gandhi'}]")

This should correctly pass the array {'text': 'gandhi'} as the body of your API request.

I hope this helps! Let me know if you have any other questions.

Sources

• libs/langchain/langchain/chains/api/openapi/chain.py

---

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.

[Nidhipriya8]

@dosu-beta, @dosu-bot I am doing exactly the same, yet I get following response
OutPut: {'instructions': "What is the API response for body = [{'text': 'gandhi'}]", 'output': 'The API you attempted to call requires additional arguments to be provided in the call. The arguments you provided were empty. Please include the arguments needed for the API call.', 'intermediate_steps': {'request_args': '{"body": [{"text": "gandhi"}], "x-correlation-id": null, "accept-language": "en"}', 'response_text': '400: Bad Request\nFor POST https:///v2\nCalled with args: {}'}}
{'request_args': '{"body": [{"text": "gandhi"}], "x-correlation-id": null, "accept-language": "en"}', 'response_text': '400: Bad Request\nFor POST https:///v2\nCalled with args: {}'}
API Response 400: Bad Request

[Nidhipriya8]

@dosu-beta @dosu-bot, The above indicates, its sending empty args

[dosubot[bot]]

🤖

Hello,

Thank you for reaching out and providing detailed information about your issue. It seems like the arguments are not being correctly passed to the API request.

In LangChain, the OpenAPIEndpointChain.from_api_operation method is responsible for creating an instance of OpenAPIEndpointChain from an APIOperation and a language model specification. This method uses the deserialize_json_input method to deserialize the input and extract the body parameters.

To correctly pass an array as the body of your API request, you need to ensure that the array is correctly serialized and passed as a string in the args dictionary. Here is how you can do it:

# Assuming you have an instance of OpenAPIEndpointChain named `chain`
args = {
    "param1": "value1",
    "param2": ["item1", "item2", "item3"]  # This is your array
}
serialized_args = json.dumps(args)
deserialized_input = chain.deserialize_json_input(serialized_args)

# Now you can use deserialized_input in your API request

In this example, param2 is the key for the array you want to pass in the body of your API request. The args dictionary is then serialized into a JSON string using json.dumps(). This serialized string is then passed to the deserialize_json_input method of the OpenAPIEndpointChain instance, which returns a dictionary that can be used in your API request.

Please ensure that the keys in the args dictionary match the parameter names expected by the API endpoint. If the keys do not match, the _extract_body_params method will not be able to find and extract the correct parameters, resulting in a 400 Bad Request error.

You can find more details about the OpenAPIEndpointChain.from_api_operation method in the LangChain codebase.

I hope this helps! If you have any other questions or need further clarification, please don't hesitate to ask.

Best,
Dosu

Sources

• libs/langchain/langchain/chains/api/openapi/chain.py

---

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.

[Nidhipriya8]

@dosu-bot, Thankyou!! the above helps for adding array keys into the body.However, my problem statement is when my body itself is an array, how do we pass that in chain.
Following is an example CURL,
curl --location 'https://localhost/apiendpoint/v2'
--header 'accept: application/json'
--header 'Content-Type: application/json'
--header 'Accept-Language: en'
--data '[
{
"text": "nature"
},
{
"text": "rejoice2"
}
]
'

[dosubot[bot]]

🤖

Hello,

From your description, it seems like you're trying to pass an array as the body of your API request using the OpenAPIEndpointChain.from_api_operation method in the LangChain Python framework.

The OpenAPIEndpointChain.from_api_operation method creates an instance of OpenAPIEndpointChain from an APIOperation object. The APIOperation object should contain the details of the body parameters in its body_params attribute.

When the API request is made, the _call method is invoked which in turn calls the deserialize_json_input method. This method extracts the body parameters from the serialized input using the _extract_body_params method.

To pass an array as the body of your API request, you need to ensure that the array is included in the body_params of the param_mapping object.

Here is how you can do it:

1. Ensure that the APIOperation object has the array parameter in its body_params attribute.
2. When making the API request, pass the array as a serialized JSON string in the inputs dictionary.

Here is an example:

# Create an APIOperation object
api_operation = APIOperation(
    base_url="http://example.com",
    path="/endpoint",
    method="POST",
    body_params=["array_param"],  # The array parameter
    # Other attributes...
)

# Create an OpenAPIEndpointChain object
chain = OpenAPIEndpointChain.from_api_operation(
    operation=api_operation,
    llm=llm,  # The language model
    # Other arguments...
)

# Make the API request
inputs = {
    "instructions": "Some instructions",
    "array_param": json.dumps([{"text": "nature"}, {"text": "rejoice2"}]),  # The array
}
output = chain.call(inputs)

In this example, "array_param" is the name of the array parameter, and [{"text": "nature"}, {"text": "rejoice2"}] is the array. The array is passed as a serialized JSON string.

You can find more details about this in the LangChain repository.

I hope this helps! Let me know if you have any other questions.

Sources

• libs/langchain/langchain/chains/api/openapi/chain.py

---

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.