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 Langfuse
 
langfuse = Langfuse()
 
# 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 update
    span.update(metadata={"step": 1, "status": "started"})
 
    # Later update - will be merged with previous metadata
    span.update(metadata={"step": 2, "error": None})
 
    # Final metadata will be {"step": 2, "status": "started", "error": null}

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,
});

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] });

from langfuse.llama_index import LlamaIndexInstrumentor
 
instrumentor = LlamaIndexInstrumentor()
 
with instrumentor.observe(metadata={"key":"value"}):
    # ... your LlamaIndex index creation ...
 
    index.as_query_engine().query("What is the capital of France?")
 
instrumentor.flush()

from langfuse.decorators import langfuse_context, observe
from langfuse.llama_index import LlamaIndexInstrumentor
 
instrumentor = LlamaIndexInstrumentor()
 
@observe()
def llama_index_fn(question: str):
    # Update context
    langfuse_context.update_current_trace(metadata={"key":"value"})
 
    # Get IDs
    current_trace_id = langfuse_context.get_current_trace_id()
    current_observation_id = langfuse_context.get_current_observation_id()
 
    # Pass to instrumentor
    with instrumentor.observe(
        trace_id=current_trace_id,
        parent_observation_id=current_observation_id,
        update_parent=False
    ) as trace:
        # ... your LlamaIndex index creation ...
 
        index.as_query_engine().query("What is the capital of France?")
 
        # Run application
        index = VectorStoreIndex.from_documents([doc1, doc2])
        response = index.as_query_engine().query(question)
 
        return response

from llama_index.core import Settings
from llama_index.core.callbacks import CallbackManager
from langfuse import langfuse
 
# Instantiate a new LlamaIndexCallbackHandler and register it in the LlamaIndex Settings
langfuse_callback_handler = LlamaIndexCallbackHandler()
Settings.callback_manager = CallbackManager([langfuse_callback_handler])
 
langfuse_callback_handler.set_trace_params(
  metadata={"key":"value"}
)

from langfuse.decorators import langfuse_context, observe
from llama_index.core import Document, VectorStoreIndex
from llama_index.core import Settings
from llama_index.core.callbacks import CallbackManager
 
@observe()
def llama_index_fn(question: str):
    langfuse_context.update_current_trace(
        metadata={"key":"value"}
    )
 
    # Set callback manager for LlamaIndex, will apply to all LlamaIndex executions in this function
    langfuse_handler = langfuse_context.get_current_llama_index_handler()
    Settings.callback_manager = CallbackManager([langfuse_handler])
 
    # Run application
    index = VectorStoreIndex.from_documents([doc1,doc2])
    response = index.as_query_engine().query(question)
    return response