How to migrate from Langfuse to HoneyHive

Use this HoneyHive migration guide: https://docs.honeyhive.ai/v2/tracing/migrate-from-langfuse.md

Explore my codebase to find Langfuse tracing, scoring, datasets, and prompts. Ask any questions needed to understand the project and runtime. Then present a concise migration plan for my confirmation. After I confirm the plan, implement the changes and verify that traces reach HoneyHive.

import os

from honeyhive import HoneyHive
from honeyhive.models import (
    AddDatapointsToDatasetRequest,
    CreateDatasetRequest,
    DatapointMapping,
)
from langfuse import get_client


def as_object(value, fallback_key):
    if isinstance(value, dict):
        return value
    return {fallback_key: value}


def unique_keys(records):
    keys = []
    for record in records:
        for key in record:
            if key not in keys:
                keys.append(key)
    return keys


def rename_until_free(name, taken, prefix):
    mapped = name
    while mapped in taken:
        mapped = f"{prefix}{mapped}"
    taken.add(mapped)
    return mapped


langfuse = get_client()
hh = HoneyHive(api_key=os.environ["HH_API_KEY"])

source = langfuse.get_dataset("golden-set")
created = hh.datasets.create(
    CreateDatasetRequest(
        name="golden-set",
        description="Imported from Langfuse",
    )
)
dataset_id = created.result.insertedId

items = list(source.items)
input_records = [as_object(item.input, "input") for item in items]
ground_truth_records = [
    as_object(item.expected_output, "expected_output")
    if item.expected_output is not None
    else {}
    for item in items
]

input_keys = unique_keys(input_records)
ground_truth_keys = unique_keys(ground_truth_records)

taken = set(input_keys)
ground_truth_key_map = {
    key: rename_until_free(key, taken, "expected_")
    for key in ground_truth_keys
}
source_metadata_key = rename_until_free("langfuse_source", taken, "_")

rows = []
for item, inputs, ground_truth in zip(
    items, input_records, ground_truth_records
):
    row = {key: inputs.get(key) for key in input_keys}
    row.update(
        {
            ground_truth_key_map[key]: ground_truth.get(key)
            for key in ground_truth_keys
        }
    )
    row[source_metadata_key] = {
        "item_id": item.id,
        "metadata": item.metadata or {},
    }
    rows.append(row)

if rows:
    hh.datasets.add_datapoints(
        dataset_id,
        AddDatapointsToDatasetRequest(
            data=rows,
            mapping=DatapointMapping(
                inputs=input_keys,
                ground_truth=list(ground_truth_key_map.values()),
            ),
        ),
    )

export LANGFUSE_PROMPT_NAME="my-prompt"
export LANGFUSE_PROMPT_VERSION="3"
export LANGFUSE_PROMPT_TYPE="chat"
export HH_PROMPT_ENVS="prod"
export HH_PROMPT_PROVIDER="openai"
export HH_PROMPT_MODEL="gpt-4o-mini"

import hashlib
import os
import re

from honeyhive import HoneyHive
from honeyhive.models import CreateConfigurationRequest
from langfuse import get_client


def valid_honeyhive_name(name: str) -> str:
    cleaned = re.sub(r"[^a-zA-Z0-9 _\-'&]", "-", name).strip()
    if cleaned == name and len(cleaned) <= 200:
        return cleaned

    digest = hashlib.sha256(name.encode()).hexdigest()[:8]
    suffix = f"-{digest}"
    return f"{cleaned[: 200 - len(suffix)]}{suffix}"


prompt_name = os.environ["LANGFUSE_PROMPT_NAME"]
prompt_version = int(os.environ["LANGFUSE_PROMPT_VERSION"])
prompt_type = os.environ.get("LANGFUSE_PROMPT_TYPE", "text")
destination_name = valid_honeyhive_name(f"{prompt_name}-v{prompt_version}")
destination_envs = [
    env.strip()
    for env in os.environ.get("HH_PROMPT_ENVS", "dev").split(",")
    if env.strip()
]
invalid_envs = set(destination_envs) - {"dev", "staging", "prod"}
if not destination_envs or invalid_envs:
    raise ValueError(f"Invalid HoneyHive environments: {sorted(invalid_envs)}")

langfuse = get_client()
honeyhive = HoneyHive(api_key=os.environ["HH_API_KEY"])

source = langfuse.get_prompt(
    prompt_name,
    version=prompt_version,
    type=prompt_type,
)
source_config = dict(source.config or {})
model = source_config.pop("model", None) or os.environ["HH_PROMPT_MODEL"]

if prompt_type == "chat":
    placeholders = [
        item["name"]
        for item in source.prompt
        if item.get("type") == "placeholder"
    ]
    if placeholders:
        raise ValueError(
            "Map Langfuse message placeholders in application code before "
            f"migrating: {placeholders}"
        )
    template = [
        {"role": item["role"], "content": item["content"]}
        for item in source.prompt
    ]
else:
    template = [{"role": "user", "content": source.prompt}]

if any(config.name == destination_name for config in honeyhive.configurations.list()):
    raise RuntimeError(f"Configuration already exists: {destination_name}")

created = honeyhive.configurations.create(
    CreateConfigurationRequest(
        name=destination_name,
        type="LLM",
        provider=os.environ["HH_PROMPT_PROVIDER"],
        parameters={
            "call_type": "chat" if prompt_type == "chat" else "completion",
            "model": model,
            "template": template,
            "hyperparameters": source_config,
        },
        env=destination_envs,
        tags=["migrated-from-langfuse"],
        user_properties={
            "langfuse_prompt_name": prompt_name,
            "langfuse_prompt_version": prompt_version,
            "langfuse_prompt_type": prompt_type,
        },
    )
)
print(created.insertedId)

Migrate this application's Langfuse prompts to HoneyHive programmatically.

1. Find every langfuse.get_prompt(...) call and record its prompt name, type,
   label or version, and how prompt.config is passed to the model provider.
2. Resolve each moving Langfuse label to an explicit version before migrating.
3. Use the Python SDK migration example at
   https://docs.honeyhive.ai/v2/tracing/migrate-from-langfuse#move-prompts to
   create one HoneyHive configuration per retained version. Convert text
   prompts to one user message, preserve chat messages and provider-specific
   config fields, and handle message placeholders in application code.
4. Map production, staging, and custom labels to explicit HoneyHive dev,
   staging, or prod environment lists. Do not map Langfuse latest
   automatically.
5. Refuse to overwrite an existing HoneyHive configuration. Show me the
   source-to-destination mapping before creating anything.
6. Update the application to fetch the deployed HoneyHive configuration,
   preserve its current prompt rendering and model arguments, and verify one
   request end to end.