Metadata

from langfuse import observe, get_client
 
langfuse = get_client()
 
@observe()
def process_data():
    # Access the client and update the current trace metadata
 
    # Add metadata to the trace level
    langfuse.update_current_trace(
        metadata={"source": "api", "version": "1.2.3"}
    )
 
    # Add metadata to the current span level
    langfuse.update_current_span(
        metadata={"processing_stage": "initial"}
    )
 
    # Process data...
    return result

from langfuse import get_client
 
langfuse = get_client()
 
# Add metadata at trace level
with langfuse.start_as_current_span(
    name="process-request"
) as root_span:
    # Add metadata to the trace
    root_span.update_trace(metadata={"request_id": "req_12345"})
 
    # Add metadata to the current span
    root_span.update(metadata={"stage": "parsing"})
 
    # Create a child span with metadata
    with root_span.start_as_current_generation(
        name="generate-response",
        model="gpt-4o",
        metadata={"temperature": 0.7, "max_tokens": 1000}
    ) as gen:
        # Update metadata later if needed
        gen.update(metadata={"completion_type": "creative"})

with langfuse.start_as_current_span(name="operation") as span:
    # First write
    span.update(metadata={"status": "started"})
 
    # Additional key - will be merged with previous metadata
    span.update(metadata={"error": "Failed to process"})
 
    # Final metadata will be {"status": "started", "error": "Failed to process"}

from langfuse.decorators import langfuse_context, observe
 
@observe
def nested():
    # Update trace metadata from anywhere inside call stack
    langfuse_context.update_current_trace(
        metadata={"key":"value"}
    )
 
    # Update observation metadata for current observation
    langfuse_context.update_current_observation(
        metadata={"key": "value"}
    )
 
    return
 
@observe
def fn():
    nested()
 
fn()

from langfuse import Langfuse
langfuse = Langfuse()
 
trace = langfuse.trace(
    metadata={"key":"value"}
)
 
span = trace.span(
    metadata={"key":"value"}
)

import { Langfuse } from "langfuse";
const langfuse = new Langfuse();
 
const trace = langfuse.trace({
  metadata: { key: "value" },
});
 
const span = trace.span({
  metadata: { key: "value" },
});

from langfuse.openai import openai
 
completion = openai.chat.completions.create(
  name="test-chat",
  model="gpt-3.5-turbo",
  messages=[
    {"role": "system", "content": "You are a calculator."},
    {"role": "user", "content": "1 + 1 = "}],
  temperature=0,
 
  # add metadata as additional argument
  metadata={"key":"value"}
)

import OpenAI from "openai";
import { observeOpenAI } from "langfuse";
 
const res = await observeOpenAI(new OpenAI(), {
  metadata: { someMetadataKey: "someValue" },
}).chat.completions.create({
  messages: [{ role: "system", content: "Tell me a story about a dog." }],
  model: "gpt-3.5-turbo",
  max_tokens: 300,
});

from langfuse.langchain import CallbackHandler
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
 
langfuse_handler = CallbackHandler()
 
llm = ChatOpenAI(model_name="gpt-4o")
prompt = ChatPromptTemplate.from_template("Tell me a joke about {topic}")
chain = prompt | llm
 
# Set trace attributes dynamically via metadata
response = chain.invoke(
    {"topic": "cats"},
    config={
        "callbacks": [langfuse_handler],
        "metadata": {
            "foo": "bar",
            "baz": "qux"
        }
    }
)

from langfuse import get_client
from langfuse.langchain import CallbackHandler
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
 
langfuse = get_client()
langfuse_handler = CallbackHandler()
 
llm = ChatOpenAI(model_name="gpt-4o")
prompt = ChatPromptTemplate.from_template("Tell me a joke about {topic}")
chain = prompt | llm
 
# Set trace attributes dynamically via enclosing span
with langfuse.start_as_current_span(name="dynamic-langchain-trace") as span:
    span.update_trace(
        metadata={"foo": "bar", "baz": "qux"}
    )
 
    response = chain.invoke({"topic": "cats"}, config={"callbacks": [langfuse_handler]})
 
    span.update_trace(output={"response": response.content})

handler = CallbackHandler(
  metadata={"key":"value"}
)

const handler = new CallbackHandler({
  metadata: { key: "value" },
});

import { CallbackHandler, Langfuse } from "langfuse-langchain";
const langfuse = new Langfuse();
 
const trace = langfuse.trace({
  metadata: { key: "value" },
});
const langfuseHandler = new CallbackHandler({ root: trace });
 
// Add Langfuse handler as callback to your langchain chain/agent
await chain.invoke({ input: "<user_input>" }, { callbacks: [langfuseHandler] });