Pular para o conteúdo principal

Acompanhe as versões do prompt junto com as versões do aplicativo

info

Beta

Esse recurso está na versão beta.

Este guia mostra como integrar prompts do MLflow Prompt Registry aos seus aplicativos GenAI e, ao mesmo tempo, acompanhar as versões do prompt e do aplicativo. Quando o senhor usa o site mlflow.set_active_model() com prompts do registro, o MLflow cria automaticamente uma linhagem entre as versões do prompt e as versões do aplicativo.

O que você aprenderá:

  • Carregar e usar prompts do MLflow Prompt Registry em seu aplicativo
  • Rastreie as versões do aplicativo usando LoggedModels
  • visualizar a linhagem automática entre as versões do prompt e as versões do aplicativo
  • Atualize as solicitações e veja como as mudanças fluem até seu aplicativo

Pré-requisitos​

  1. Instale o site MLflow e o pacote necessário

    Bash
    pip install --upgrade "mlflow[databricks]>=3.1.0" openai

  2. Crie um experimento MLflow seguindo o início rápido de configuração do ambiente.

  3. Certifique-se de ter acesso a um esquema do Unity Catalog com as permissões CREATE FUNCTION, EXECUTE e MANAGE para usar o registro de prompt.

nota

É necessário ter um esquema Unity Catalog com as permissões CREATE FUNCTION, EXECUTE e MANAGE para view ou criar prompts. Se estiver usando uma avaliaçãoDatabricks account , o senhor tem as permissões necessárias no esquema Unity Catalog workspace.default.

Etapa 1: criar um prompt no registro​

Primeiro, vamos criar um prompt que usaremos em nosso aplicativo. Se o senhor já tiver criado um prompt seguindo o guia Criar e editar prompts, poderá pular esta etapa.

Python
import mlflow

# Replace with a Unity Catalog schema where you have CREATE FUNCTION, EXECUTE, and MANAGE permission
uc_schema = "workspace.default"
prompt_name = "customer_support_prompt"

# Define the prompt template with variables
initial_template = """\
You are a helpful customer support assistant for {{company_name}}.

Please help the customer with their inquiry about: {{topic}}

Customer Question: {{question}}

Provide a friendly, professional response that addresses their concern.
"""

# Register a new prompt
prompt = mlflow.genai.register_prompt(
    name=f"{uc_schema}.{prompt_name}",
    template=initial_template,
    commit_message="Initial customer support prompt",
    tags={
        "author": "support-team@company.com",
        "use_case": "customer_service"
        "department": "customer_support",
        "language": "en"
    }
)

print(f"Created prompt '{prompt.name}' (version {prompt.version})")

Etapa 2: Crie um aplicativo com o controle de versão ativado que use o prompt​

Agora vamos criar um aplicativo GenAI que carrega e usa esse prompt do registro. Usaremos mlflow.set_active_model() para rastrear a versão do aplicativo.

Quando o senhor chama mlflow.set_active_model(), o MLflow cria um LoggedModel que serve como um hub de metadados para a versão do seu aplicativo. Esse LoggedModel não armazena o código real do aplicativo; em vez disso, ele atua como um registro central que vincula o código externo (como um commit do Git), parâmetros de configuração e rastreia automaticamente quais prompts do registro o aplicativo usa. Para obter uma explicação detalhada de como funciona o acompanhamento da versão do aplicativo, consulte rastrear versões de aplicativos com MLflow.

Python
import mlflow
import subprocess
from openai import OpenAI

# Enable MLflow's autologging to instrument your application with Tracing
mlflow.openai.autolog()

# Connect to a Databricks LLM via OpenAI using the same credentials as MLflow
# Alternatively, you can use your own OpenAI credentials here
mlflow_creds = mlflow.utils.databricks_utils.get_databricks_host_creds()
client = OpenAI(
    api_key=mlflow_creds.token,
    base_url=f"{mlflow_creds.host}/serving-endpoints"
)

# Define your application and its version identifier
app_name = "customer_support_agent"

# Get current git commit hash for versioning
try:
    git_commit = (
        subprocess.check_output(["git", "rev-parse", "HEAD"])
        .decode("ascii")
        .strip()[:8]
    )
    version_identifier = f"git-{git_commit}"
except subprocess.CalledProcessError:
    version_identifier = "local-dev"  # Fallback if not in a git repo
logged_model_name = f"{app_name}-{version_identifier}"

# Set the active model context - this creates a LoggedModel that represents this version of your application
active_model_info = mlflow.set_active_model(name=logged_model_name)
print(
    f"Active LoggedModel: '{active_model_info.name}', Model ID: '{active_model_info.model_id}'"
)

# Log application parameters
# These parameters help you track the configuration of this app version
app_params = {
    "llm": "databricks-claude-sonnet-4",
    "temperature": 0.7,
    "max_tokens": 500
}
mlflow.log_model_params(model_id=active_model_info.model_id, params=app_params)

# Load the prompt from the registry
# NOTE: Loading the prompt AFTER calling set_active_model() is what enables
# automatic lineage tracking between the prompt version and the LoggedModel
prompt = mlflow.genai.load_prompt(f"prompts:/{uc_schema}.{prompt_name}/1")
print(f"Loaded prompt version {prompt.version}")

# Use the trace decorator to capture the application's entry point
# Each trace created by this function will be automatically linked to the LoggedModel (application version) we set above.  In turn, the LoggedModel is linked to the prompt version that was loaded from the registry
@mlflow.trace
def customer_support_app(company_name: str, topic: str, question: str):
    # Format the prompt with variables
    formatted_prompt = prompt.format(
        company_name=company_name,
        topic=topic,
        question=question
    )

    # Call the LLM
    response = client.chat.completions.create(
        model="databricks-claude-sonnet-4",  # Replace with your model
        messages=[
            {
                "role": "user",
                "content": formatted_prompt,
            },
        ],
        temperature=0.7,
        max_tokens=500
    )
    return response.choices[0].message.content

# Test the application
result = customer_support_app(
    company_name="TechCorp",
    topic="billing",
    question="I was charged twice for my subscription last month. Can you help?"
)
print(f"\nResponse: {result}")

Etapa 3: visualizar a linhagem automática​

Etapa 4: atualize o prompt e acompanhe a alteração​

Vamos melhorar nossa solicitação e ver como a nova versão é rastreada automaticamente quando a usamos em nosso aplicativo.

Python
# Create an improved version of the prompt
improved_template = """\
You are a helpful and empathetic customer support assistant for {{company_name}}.

Customer Topic: {{topic}}
Customer Question: {{question}}

Please provide a response that:
1. Acknowledges the customer's concern with empathy
2. Provides a clear solution or next steps
3. Offers additional assistance if needed
4. Maintains a friendly, professional tone

Remember to:
- Use the customer's name if provided
- Be concise but thorough
- Avoid technical jargon unless necessary
"""

# Register the new version
updated_prompt = mlflow.genai.register_prompt(
    name=f"{uc_schema}.{prompt_name}",
    template=improved_template,
    commit_message="Added structured response guidelines for better customer experience",
    tags={
        "author": "support-team@company.com",
        "improvement": "Added empathy guidelines and response structure"
    }
)

print(f"Created version {updated_prompt.version} of '{updated_prompt.name}'")

Etapa 5: use o prompt atualizado em seu aplicativo​

Agora, vamos usar a nova versão do prompt e criar uma nova versão do aplicativo para rastrear essa alteração:

Python
# Create a new application version
new_version_identifier = "v2-improved-prompt"
new_logged_model_name = f"{app_name}-{new_version_identifier}"

# Set the new active model
active_model_info_v2 = mlflow.set_active_model(name=new_logged_model_name)
print(
    f"Active LoggedModel: '{active_model_info_v2.name}', Model ID: '{active_model_info_v2.model_id}'"
)

# Log updated parameters
app_params_v2 = {
    "llm": "databricks-claude-sonnet-4",
    "temperature": 0.7,
    "max_tokens": 500,
    "prompt_version": "2"  # Track which prompt version we're using
}
mlflow.log_model_params(model_id=active_model_info_v2.model_id, params=app_params_v2)

# Load the new prompt version
prompt_v2 = mlflow.genai.load_prompt(f"prompts:/{uc_schema}.{prompt_name}/2")

# Update the app to use the new prompt
@mlflow.trace
def customer_support_app_v2(company_name: str, topic: str, question: str):
    # Format the prompt with variables
    formatted_prompt = prompt_v2.format(
        company_name=company_name,
        topic=topic,
        question=question
    )

    # Call the LLM
    response = client.chat.completions.create(
        model="databricks-claude-sonnet-4",
        messages=[
            {
                "role": "user",
                "content": formatted_prompt,
            },
        ],
        temperature=0.7,
        max_tokens=500
    )
    return response.choices[0].message.content

# Test with the same question to see the difference
result_v2 = customer_support_app_v2(
    company_name="TechCorp",
    topic="billing",
    question="I was charged twice for my subscription last month. Can you help?"
)
print(f"\nImproved Response: {result_v2}")

Próximas etapas: avaliar as versões do prompt​

Agora que você rastreou diferentes versões de seus prompts e aplicativos, você pode avaliar sistematicamente quais versões de prompts funcionam melhor. A estrutura de avaliação do MLflow permite que o senhor compare várias versões de prompt lado a lado usando juízes LLM e métricas personalizadas.

Para saber como avaliar suas versões de solicitações, consulte avaliar solicitações. Este guia mostra ao senhor como fazer isso:

  • avaliações de execução em diferentes versões do prompt
  • Compare os resultados entre as versões usando a interface de avaliação
  • Use tanto os juízes integrados do LLM quanto as métricas personalizadas
  • Tome data-driven decisões sobre qual versão do prompt deve ser implantada

Ao combinar o controle de versão de prompts com a avaliação, o senhor pode melhorar iterativamente seus prompts com confiança, sabendo exatamente como cada alteração afeta as métricas de qualidade.

Próximas etapas​

Última atualização em