Is it okay to keep an async checkpointer as singleton?

[nimishdm-airindia]

I'm using FastAPI with AsyncMongoDBSaver. I keep the checkpointer in a global variable and dispose it only when the lifetime of the FastAPI app ends. I guess this means the async mongo client will get closed only when the lifetime ends. Is this the right way to do it?

from langgraph.checkpoint.mongodb.aio import AsyncMongoDBSaver


DB_URI = "URI"
graph = None
checkpointer_cm = None
checkpointer = None


@asynccontextmanager
async def lifespan(app: FastAPI):
    global graph, checkpointer_cm, checkpointer
    checkpointer_cm = AsyncMongoDBSaver.from_conn_string(DB_URI)
    checkpointer = await checkpointer_cm.__aenter__()

    builder = StateGraph(State)
    graph = builder.compile(checkpointer=checkpointer)
    yield
    if checkpointer_cm:
        await checkpointer_cm.__aexit__(None, None, None)

app = FastAPI(lifespan=lifespan)

async def invoke_graph(input_obj, config) -> AsyncGenerator[bytes, None]:
    async for event in graph.astream(
        input_obj,
        config=config,
        stream_mode="values",
    ):
        message = event["messages"][-1]
        message.pretty_print()
        if isinstance(message, AIMessage):
            yield f"data: {message.content}\n\n"

@app.post("/messages")
async def process_message(message: ChatMessage):
    thread_config = {"configurable": {"thread_id": message.conversation_id}}
    snapshot = await graph.aget_state(thread_config)
    input_obj = {"messages": [{"role": "user", "content": message.content}]}

    # Handle interrupt
    if len(snapshot.next) > 0:
        input_obj = Command(resume=message.content)

    return StreamingResponse(
        invoke_graph(input_obj, thread_config),
        status_code=200,
        media_type="text/event-stream",
    )

For context, this is the code for AsyncMongoDBSaver.from_conn_string(DB_URI) from the langgraph.checkpoint.mongodb.aio library.

@classmethod
    @asynccontextmanager
    async def from_conn_string(
        cls,
        conn_string: str,
        db_name: str = "checkpointing_db",
        checkpoint_collection_name: str = "checkpoints_aio",
        writes_collection_name: str = "checkpoint_writes_aio",
        **kwargs: Any,
    ) -> AsyncIterator[AsyncMongoDBSaver]:
        """Create asynchronous checkpointer

        This includes creation of collections and indexes if they don't exist
        """
        client: Optional[AsyncIOMotorClient] = None
        try:
            client = AsyncIOMotorClient(
                conn_string,
                driver=DriverInfo(
                    name="Langgraph", version=version("langgraph-checkpoint-mongodb")
                ),
            )
            saver = AsyncMongoDBSaver(
                client,
                db_name,
                checkpoint_collection_name,
                writes_collection_name,
                **kwargs,
            )
            await saver._setup()
            yield saver

        finally:
            if client:
                client.close()