Suivre les versions d'invite parallèlement aux versions d'application

info

Bêta

Cette fonctionnalité est en Bêta. Les administrateurs du Workspace peuvent contrôler l'accès à cette fonctionnalité à partir de la page Previews . Consultez Gérer les aperçus Databricks.

Ce guide vous montre comment intégrer des prompts du registre de prompts MLflow dans vos applications GenAI tout en suivant les versions des prompts et des applications conjointement. Lorsque vous utilisez mlflow.set_active_model() avec des invites du registre, MLflow crée automatiquement un lignage entre vos versions d’invite et vos versions d’application.

Ce guide couvre les étapes suivantes :

Charger et utiliser des invites du Registre d'invites MLflow dans votre application.
Suivez les versions de l'application en utilisant LoggedModels.
Afficher le lignage automatique entre les versions d’invite et les versions d’application.
Mettez à jour les invites et voyez comment les modifications se répercutent sur votre application.

Tout le code de cette page est inclus dans l'exemple de notebook.

Prérequis

Installer MLflow et les packages requis

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

Créez une expérience MLflow en suivant le guide de démarrage rapide de configuration de votre environnement.
Assurez-vous d'avoir accès à un schéma Unity Catalog avec les permissions CREATE FUNCTION, EXECUTE et MANAGE pour utiliser le registre d'invites.

remarque

Un schéma Unity Catalog avec les autorisations CREATE FUNCTION, EXECUTE et MANAGE est requis pour afficher ou créer des invites. Si vous utilisez un compte d'essai Databricks, vous disposez des autorisations requises sur le schéma Unity Catalog workspace.default.

Étape 1 : Créer une invite dans le registre

Tout d'abord, créons une invite que nous utiliserons dans notre application. Si vous avez déjà créé une invite en suivant le guide Créer et modifier des invites, vous pouvez ignorer cette étape.

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={
        &quot;author&quot;: &quot;support-team@company.com&quot;,
        &quot;use_case&quot;: &quot;customer_service&quot;,
        &quot;department&quot;: &quot;customer_support&quot;,
        &quot;language&quot;: &quot;en&quot;
    }
)

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

Étape 2 : Créez une application avec versioning activé qui utilise l'invite

Nous allons maintenant créer une application GenAI qui charge et utilise ce prompt à partir du registre. Nous utiliserons mlflow.set_active_model() pour suivre la version de l'application.

Lorsque vous appelez mlflow.set_active_model(), MLflow crée un LoggedModel qui sert de hub de métadonnées pour la version de votre application. Ce LoggedModel ne stocke pas votre code d'application réel - au lieu de cela, il agit comme un enregistrement central qui se lie à votre code externe (comme un commit Git), aux paramètres de configuration et suit automatiquement les invites du registre utilisées par votre application.

Initialisez un client OpenAI pour vous connecter soit à des LLM hébergés par Databricks, soit à des LLM hébergés par OpenAI.

Databricks-hosted LLMs
OpenAI-hosted LLMs

Utilisez databricks-openai pour obtenir un client OpenAI qui se connecte aux LLM hébergés par Databricks. Sélectionnez un modèle parmi les modèles de fondation disponibles.

Python
import mlflow
from databricks_openai import DatabricksOpenAI

# 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
client = DatabricksOpenAI()

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

Utilisez le SDK natif OpenAI pour vous connecter aux modèles hébergés par OpenAI. Sélectionnez un modèle parmi les modèles OpenAI disponibles.

Python
import mlflow
import os
import openai

# Ensure your OPENAI_API_KEY is set in your environment
# os.environ["OPENAI_API_KEY"] = "<YOUR_API_KEY>" # Uncomment and set if not globally configured

# Enable auto-tracing for OpenAI
mlflow.openai.autolog()

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

# Create an OpenAI client connected to OpenAI SDKs
client = openai.OpenAI()

# Select an LLM
model_name = "gpt-4o-mini"

Définissez votre application avec gestion des versions :

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

Étape 3 : Afficher la traçabilité automatique dans l’interface utilisateur

Lorsque vous utilisez des invites du registre dans une application qui a un jeu de modèles actif, MLflow suit automatiquement la relation entre la version de l'invite et la version de l'application.

Accédez à votre expérimentation dans l'interface utilisateur de l'Expérimentation MLflow. Sur la page Expérimentation, cliquez sur l'onglet tab . La version de l'invite apparaît dans le tableau comme indiqué.

Tab versions de l'expérimentation avec la version d'invite.

Étape 4 : Mettez à jour le prompt et suivez le changement

Améliorons notre invite et voyons comment la nouvelle version est automatiquement suivie lorsque nous l'utilisons dans notre application.

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={
        &quot;author&quot;: &quot;support-team@company.com&quot;,
        &quot;improvement&quot;: &quot;Added empathy guidelines and response structure&quot;
    }
)

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

Étape 5 : Utilisez l'invite mise à jour dans votre application

Utilisons maintenant la nouvelle version d'invite et créons une nouvelle version d'application pour suivre cette modification :

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

Exemple de Notebook

Le Notebook suivant inclut l'ensemble du code sur cette page.

Suivre les versions de prompt et d'application Notebook

Ouvrir le notebook dans un nouvel onglet Ouvrir dans Databricks

Étapes suivantes : Évaluer les versions d'invite.

Maintenant que vous avez suivi différentes versions de vos invites et applications, vous pouvez évaluer systématiquement quelles versions d'invite offrent les meilleures performances. Le framework d’évaluation de MLflow vous permet de comparer plusieurs versions de prompts côte à côte à l’aide de juges LLM et de métriques personnalisées.

Pour savoir comment évaluer la qualité des différentes versions de prompt, consultez évaluer les prompts. Ce guide vous montre comment :

Exécuter des évaluations sur différentes versions d'invite.
Comparez les résultats entre les versions à l'aide de l'interface utilisateur d'évaluation.
Utilisez à la fois les juges LLM intégrés et des métriques personnalisées.
Prenez des décisions data-driven quant à la version d'invite à déployer.

En combinant la gestion de versions des prompts avec l'évaluation, vous pouvez améliorer de manière itérative vos prompts en toute confiance, sachant exactement comment chaque changement impacte les métriques de qualité.

Prérequis​

Étape 1 : Créer une invite dans le registre​

Étape 2 : Créez une application avec versioning activé qui utilise l'invite​

Étape 3 : Afficher la traçabilité automatique dans l’interface utilisateur​

Étape 4 : Mettez à jour le prompt et suivez le changement​

Étape 5 : Utilisez l'invite mise à jour dans votre application​

Exemple de Notebook​