How can we langfuse with different API keys in the same environment.

[snopoke]

I'm building a multi-tenant bot platform where I'm supporting multiple tracing agents including langfuse. The model we're using is that clients bring their own API key so that the trace data goes into their account.

The way we're doing this now is to create a CallbackHandler with the client's auth for each chain execution:

handler = CallbackHandler(**client_config)

We can't use the observe decorator because the is no way to customise the langfuse client for each execution (since it uses a global client instance).

I'm creating this issue because while the callback handler approach is working I notice that the get_trace_url and get_trace_id methods are deprecated and marked for removal.

Is there a better way for us to approach this?

[dosubot[bot]]

Hey @snopoke! I'm here to help you out with any bugs, questions, or contributions you have in mind. Let's work on tackling this issue together.

To handle multiple API keys in a multi-tenant environment with Langfuse, you can continue using the CallbackHandler approach, which allows you to customize the client configuration for each execution. This is necessary since the observe decorator uses a global client instance, which doesn't support per-execution customization.

Regarding the deprecation of get_trace_url and get_trace_id, there isn't specific information available on their alternatives. However, you can dynamically set attributes for each execution by passing configuration options such as trace_name, user_id, session_id, and tags directly to the chain invocation. This allows you to customize the Langfuse handler for each execution without needing to instantiate a new CallbackHandler each time.

Here's an example of how you can customize the Langfuse client instance for each execution:

from langfuse.callback import CallbackHandler

langfuse_handler = CallbackHandler()

trace_name = "langchain_trace_name"
session_id = "random-session"
user_id = "random-user"
tags = ["random-tag-1", "random-tag-2"]

# Your existing Langchain code to create the chain

# Pass config to the chain invocation to be parsed as Langfuse trace attributes
chain.invoke(
    {"animal": "dog"},
    config={
        "callbacks": [langfuse_handler],
        "run_name": trace_name,
        "tags": tags,
        "metadata": {
            "langfuse_session_id": session_id,
            "langfuse_user_id": user_id,
        },
    },
)

This approach allows you to maintain flexibility and ensure that each client's data is handled separately. If you need further customization or encounter issues with deprecated methods, checking the latest Langfuse documentation or updates might provide additional insights or alternatives ^[1].

To continue talking to Dosu, mention @dosu.