sys:1: ResourceWarning: unclosed <socket.socket ERROR while using ainvoke method of ChatOpenAI

[BalasubramanyamEvani]

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

async def get_chat_response(self, messages: list, websocket=None) -> str:
   from langchain_openai import ChatOpenAI
   llm = ChatOpenAI(**kwargs)
   # Asynchronous invoking
   output = await self.llm.ainvoke(messages) # Error here
   ...

Description

I am trying to use langchain library to interact with openai models by invoking the async methods, but while invoking it throws the below error:

sys:1: ResourceWarning: unclosed <socket.socket fd=18, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=6, laddr=('192.168.1.167', 56270), raddr=('104.18.6.192', 443)>

There seem to be some resource (session probably) which isn't handled well, and I can't seem find any method which would allow me to close the resouce

Any inputs on how to solve this would be really appreciated. Thanks!

System Info

langchain==0.2.16
langchain-community==0.2.16
langchain-core==0.2.38
langchain-huggingface==0.0.3
langchain-openai==0.1.23
langchain-text-splitters==0.2.2
langchain-weaviate==0.0.2

Python version: 3.10.14

[dosubot[bot]]

To resolve the "sys:1: ResourceWarning: unclosed <socket.socket" error when using the ainvoke method of ChatOpenAI in the LangChain library, you need to ensure that the socket is properly closed after the asynchronous operation. This can be done by using a context manager to handle the socket connection.

Here is an example of how you can modify the ainvoke method to ensure the socket is properly closed:

import importlib
from contextlib import asynccontextmanager

@asynccontextmanager
async def manage_socket(model_config, converted_messages):
    try:
        yield await model_config.ainvoke(converted_messages)
    finally:
        await model_config.close()  # Ensure the socket is closed

class ChatCompletion:
    """Chat completion."""

    @staticmethod
    async def acreate(
        messages: list,
        *,
        provider: str = "ChatOpenAI",
        stream: bool = False,
        **kwargs: Any,
    ) -> dict:
        models = importlib.import_module("langchain.chat_models")
        model_cls = getattr(models, provider)
        model_config = model_cls(**kwargs)
        converted_messages = convert_openai_messages(messages)
        if not stream:
            async with manage_socket(model_config, converted_messages) as result:
                return {"choices": [{"message": convert_message_to_dict(result)}]}
        else:
            return (
                _convert_message_chunk_to_delta(c, i)
                async for i, c in aenumerate(model_config.astream(converted_messages))
            )

In this example, the manage_socket context manager ensures that the socket is properly closed after the ainvoke method completes. This should resolve the "sys:1: ResourceWarning: unclosed <socket.socket" error ^[1].

Additionally, you might want to check if there are any existing context managers or utility functions in the LangChain library that handle resource cleanup. The library provides context managers like trace_as_chain_group and atrace_as_chain_group for synchronous and asynchronous operations, respectively, which can be useful for managing resource cleanup ^[2].

For best practices, the LangChain documentation recommends using and extending AsyncCallbackHandler to avoid blocking the event loop and managing resources effectively in an async environment ^[3].

To continue talking to Dosu, mention @dosu.