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 demonstra como integrar prompts do Registro de Prompts MLflow em seus aplicativos GenAI, acompanhando simultaneamente as versões dos prompts e dos aplicativos. Quando você utiliza mlflow.set_active_model() com prompts do registro, o MLflow cria automaticamente uma linhagem entre as versões dos prompts e as versões do aplicativo.

Este guia aborda as seguintes etapas:

  • Carregue e utilize prompts do Registro de Prompts do MLflow 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 alterações fluem até seu aplicativo.

Todo o código desta página está incluído no Notebook de exemplo.

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.

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 você chama mlflow.set_active_model(), o MLflow cria um LoggedModel que funciona como um hub de metadados para a versão do seu aplicativo. Este LoggedModel não armazena o código real da sua aplicação - em vez disso, funciona como um registro central que se conecta ao seu código externo (como um commit Git), parâmetros de configuração e rastreia automaticamente quais prompts do registro sua aplicação utiliza. Para obter uma explicação detalhada sobre como funciona o acompanhamento da versão do aplicativo, consulte acompanhar versões de aplicativos com MLflow.

  1. Inicialize um cliente OpenAI para se conectar a LLMs hospedados pela Databricks ou LLMs hospedados pela OpenAI.

Use o MLflow para obter um cliente OpenAI que se conecta aos LLMs hospedados pela Databricks. Selecione um modelo dentre os modelos de base disponíveis.

Python
import mlflow
from databricks.sdk import WorkspaceClient

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

# Set up MLflow tracking to Databricks
mlflow.set_tracking_uri("databricks")
mlflow.set_experiment("/Shared/docs-demo")

# Create an OpenAI client that is connected to Databricks-hosted LLMs
w = WorkspaceClient()
client = w.serving_endpoints.get_open_ai_client()

# Select an LLM
model_name = "databricks-claude-sonnet-4"

  1. Defina seu aplicativo com controle de versão:

    Python
    import subprocess


    # 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": model_name,
        "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 is 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=model_name,  # 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}")

Passo 3: visualizar a linhagem automática na interface do usuário​

Quando você utiliza prompts do registro em um aplicativo que possui um conjunto de modelos ativo, o MLflow rastreia automaticamente a relação entre a versão do prompt e a versão do aplicativo.

Navegue até o seu experimento na interface do usuário do MLflow Experiment. Na página Experimento, clique em Versões tab. A versão do prompt aparece na tabela conforme mostrado.

Versões tab da experiência com versão rápida.

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}")

Exemplo de notebook​

O Notebook a seguir inclui todo o código desta página.

Acompanhe as versões do prompt e do aplicativo Caderno

Open notebook in new tab

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 a qualidade de diferentes versões de solicitações, consulte avaliar solicitações. Este guia mostra como:

  • Avaliações de execução em diferentes versões do prompt.
  • Compare os resultados entre as versões usando a interface de avaliação.
  • Utilize tanto os juízes integrados LLM quanto métricas personalizadas.
  • Tome uma decisi data-driven e 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.

Para saber como usar rastreamentos de produção para rastrear versões em ambientes de produção, consulte Vincular rastreamentos de produção a versões de aplicativos.

Última atualização em