Issue: How to create async calls to custom LLMs
Labels: name: enhancement, name: question

### Issue you'd like to raise.

Hello!

I am currently using Langchain to interface with a [customLLM](https://python.langchain.com/docs/modules/model_io/models/llms/how_to/custom_llm) async.
To do so, I am overriding the original `LLM` class as explained in the tutorial as such:

```

class LLMInterface(LLM):
    @property
    def _llm_type(self) -> str:
        return "Ruggero's LLM"

    async def send_request(self, payload):
        return await some_function_that_queries_custom_llm(payload)

    def _call(
        self,
        prompt: str,
        stop: Optional[List[str]] = None,
        run_manager: Optional[CallbackManagerForLLMRun] = None,
    ) -> str:
        if stop is not None:
            raise ValueError("stop kwargs are not permitted.")
        payload = json.dumps({"messages": [{"role": "user", "content": prompt}]})
        future = self.run_in_executor(self.send_request, payload)
        raw_response = future.result()  # get the actual result
        print(raw_response)
        # Parse JSON response
        response_json = json.loads(raw_response)
        # Extract content
        for message in response_json["messages"]:
            if message["role"] == "bot":
                content = message["content"]
                return content

        # Return empty string if no bot message found
        return ""
```
Unfortunately I get:
```
    159                     reductor = getattr(x, "__reduce_ex__", None)
    160                     if reductor is not None:
--> 161                         rv = reductor(4)
    162                     else:
    163                         reductor = getattr(x, "__reduce__", None)
TypeError: cannot pickle '_queue.SimpleQueue' object
```

Even if a use an executor I get the similar problem
```
    def run_in_executor(self, coro_func: Any, *args: Any) -> Any:
        future_result = Future()

        def wrapper():
            loop = asyncio.new_event_loop()
            asyncio.set_event_loop(loop)
            try:
                result = loop.run_until_complete(coro_func(*args))

                future_result.set_result(result)
            except Exception as e:
                future_result.set_exception(e)
            finally:
                loop.run_until_complete(loop.shutdown_asyncgens())
                loop.close()

        Thread(target=wrapper).start()
        return future_result
```
In my code I use Langchain as such:
```
        llm_chain = ConversationChain(llm=llm, memory=memory)
        output = llm_chain.run(self.llm_input)
```

What is the appropriate way to interface a custom LLM that it is queried async?
i know that Langchain supports [async calls ](https://blog.langchain.dev/async-api/) but I was not able to make it work

Thank you!

### Suggestion:

providing a 

```
    async def _async_call(
        self,
        prompt: str,
        stop: Optional[List[str]] = None,
        run_manager: Optional[CallbackManagerForLLMRun] = None,
    ) -> str:
```

method would be ideal
Any alternative work-around would be fine too 
Thank you!