Simulation de conversation

La simulation de conversation vous permet de générer des conversations multi-tours synthétiques pour tester vos agents d'IA conversationnelle. Au lieu de créer manuellement des conversations de test ou d'attendre les données de production, vous pouvez définir des scénarios de test et laisser MLflow simuler automatiquement des interactions utilisateur réalistes.

remarque

La simulation de conversation est expérimentale. L'API et le comportement pourraient changer dans les futures versions.

Prérequis

Installez MLflow 3.10.0 ou version ultérieure :

Bash

pip install --upgrade 'mlflow[databricks]>=3.10'

Pourquoi simuler des conversations ?

Aspect	Données de test manuelles	Simulation de conversation
Test de version	Impossible de retester les nouvelles versions d'agents avec les mêmes conversations	Rejouer des scénarios identiques dans toutes les versions d'agent
Couverture	Limité par la créativité humaine et le temps	Générez des cas limites diversifiés à grande échelle.
Cohérence	Variations dans la création de tests manuels	Scénarios de test reproductibles avec des objectifs définis
Adapter	Long de créer de nombreux cas de test	Générer des centaines de conversations instantanément
Maintenance	Mettre à jour manuellement les données de test	Régénérez les conversations lorsque les exigences changent

Aspect	Données de test manuelles	Simulation de conversation
Test de version	Impossible de retester les nouvelles versions d'agents avec les mêmes conversations	Rejouer des scénarios identiques dans toutes les versions d'agent
Couverture	Limité par la créativité humaine et le temps	Générez des cas limites diversifiés à grande échelle.
Cohérence	Variations dans la création de tests manuels	Scénarios de test reproductibles avec des objectifs définis
Adapter	Long de créer de nombreux cas de test	Générer des centaines de conversations instantanément
Maintenance	Mettre à jour manuellement les données de test	Régénérez les conversations lorsque les exigences changent

La simulation de conversation relève ces défis en générant des conversations par programmation basées sur des objectifs et des personas définis, permettant :

• Évaluation systématique : testez différentes versions d’agents avec des objectifs et des personas cohérents.
• Red-teaming : Test de résistance des agents avec des comportements d'utilisateur diversifiés à grande échelle
• Itérations rapides : Générez de nouvelles conversations de test instantanément lorsque les exigences changent.

Workflow

1. Définir les cas de test ou les extraire de conversations existantes - Spécifiez les objectifs, les personas et le contexte de chaque conversation simulée, ou générez-les à partir de sessions de production.
2. **Créer un simulateur** – Initialisez ConversationSimulator avec vos cas de test et votre configuration.
3. Définissez votre agent - Implémentez votre agent dans une fonction qui accepte l'historique des conversations.
4. Exécuter l'évaluation — Transmettez le simulateur à mlflow.genai.evaluate() avec vos évaluateurs.

Quick start

Voici un exemple complet qui simule des conversations et les évalue :

Python

import mlflow
from mlflow.genai.simulators import ConversationSimulator
from mlflow.genai.scorers import ConversationCompleteness, Safety
from openai import OpenAI

client = OpenAI()

# 1. Define test cases with goals (required) and optional persona/context
test_cases = [
    {
        "goal": "Successfully configure experiment tracking",
    },
    {
        "goal": "Identify and fix a model deployment error",
        "persona": "You are a frustrated data scientist who has been stuck on this issue for hours",
    },
    {
        "goal": "Set up model versioning for a production pipeline",
        "persona": "You are a beginner who needs step-by-step guidance",
        "context": {
            "user_id": "beginner_123"
        },  # user_id is passed to predict_fn via kwargs
    },
]

# 2. Create the simulator
simulator = ConversationSimulator(
    test_cases=test_cases,
    max_turns=5,
)


# 3. Define your agent function
def predict_fn(input: list[dict], **kwargs):
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=input,
    )
    return response.choices[0].message.content


# 4. Run evaluation with conversation and single-turn scorers
results = mlflow.genai.evaluate(
    data=simulator,
    predict_fn=predict_fn,
    scorers=[
        ConversationCompleteness(),  # Multi-turn scorer
        Safety(),  # Single-turn scorer (applied to each turn)
    ],
)

Définition des cas de test

Chaque cas de test représente un scénario de conversation. Les cas de test prennent en charge trois champs :

Champ	Obligatoire	Description
goal	Oui	Ce que l'utilisateur simulé tente d'accomplir
persona	Non	Description de la personnalité et du style de communication de l'utilisateur
context	Non	Kwargs supplémentaires transmis à votre fonction de prédiction

Champ	Obligatoire	Description
goal	Oui	Ce que l'utilisateur simulé tente d'accomplir
persona	Non	Description de la personnalité et du style de communication de l'utilisateur
context	Non	Kwargs supplémentaires transmis à votre fonction de prédiction

Objectif

L'objectif décrit ce que l'utilisateur simulé souhaite atteindre. Il devrait être suffisamment spécifique pour guider la conversation, mais aussi suffisamment ouvert pour permettre un dialogue naturel. Les bons objectifs décrivent le résultat attendu afin que le simulateur sache quand l'intention de l'utilisateur a été accomplie :

Python

# Good goals - specific, actionable, and describe expected outcomes
{"goal": "Successfully configure MLflow tracking for a distributed training job"}
{"goal": "Understand when to use experiments vs. runs in MLflow"}
{"goal": "Identify and fix why model artifacts aren't being logged"}

# Less effective goals - too vague, no expected outcome
{"goal": "Learn about MLflow"}
{"goal": "Get help"}

Profil

Le profil détermine la manière dont l'utilisateur simulé communique. Si non spécifié, un profil utilisateur utile par default est utilisé :

Python

# Technical expert who asks detailed questions
{
    "goal": "Reduce model serving latency below 100ms",
    "persona": "You are a senior ML engineer who asks precise technical questions",
}

# Beginner who needs more guidance
{
    "goal": "Successfully set up experiment tracking",
    "persona": "You are new to MLflow and need step-by-step explanations",
}

# Frustrated user testing agent resilience
{
    "goal": "Fix a deployment blocking production",
    "persona": "You are impatient because this is blocking a release",
}

Contexte

Le champ de contexte transmet des paramètres supplémentaires à votre fonction de prédiction. Ceci est utile pour :

• Transmission des identifiants utilisateur pour la personnalisation
• Fourniture de l'état de session ou de la configuration
• Y compris les métadonnées dont votre agent a besoin

Python

{
    "goal": "Get personalized model recommendations",
    "context": {
        "user_id": "enterprise_user_42",  # user_id is passed to predict_fn via kwargs
        "subscription_tier": "premium",
        "preferred_framework": "pytorch",
    },
}

Définir des cas de test

La façon la plus simple de définir des cas de test est sous forme de liste de dictionnaires ou de DataFrame :

Python

test_cases = [
    {"goal": "Successfully configure experiment tracking"},
    {"goal": "Debug a deployment error", "persona": "Senior engineer"},
    {"goal": "Set up a CI/CD pipeline for ML", "context": {"team": "platform"}},
]

simulator = ConversationSimulator(test_cases=test_cases)

Vous pouvez également utiliser un DataFrame :

Python

import pandas as pd

df = pd.DataFrame(
    [
        {"goal": "Successfully configure experiment tracking"},
        {"goal": "Debug a deployment error", "persona": "Senior engineer"},
        {"goal": "Set up a CI/CD pipeline for ML"},
    ]
)

simulator = ConversationSimulator(test_cases=df)

Générer des cas de test à partir de conversations existantes

Générez des cas de test à partir de sessions de conversation existantes à l'aide de generate_test_cases. Ceci est utile pour créer des cas de test qui reflètent le comportement réel des utilisateurs à partir des conversations de production :

Python

import mlflow
from mlflow.genai.simulators import generate_test_cases, ConversationSimulator

# Get existing sessions from your experiment
sessions = mlflow.search_sessions(
    locations=["<experiment-id>"],
    max_results=50,
)

# Generate test cases by extracting goals and personas from sessions
test_cases = generate_test_cases(sessions)

# Optionally, save generated test cases as a dataset for reproducibility
from mlflow.genai.datasets import create_dataset

dataset = create_dataset(name="generated_scenarios")
dataset.merge_records([{"inputs": tc} for tc in test_cases])

# Use generated test cases with the simulator
simulator = ConversationSimulator(test_cases=test_cases)

Suivez les cas de test en tant que dataset MLflow

Pour des tests reproductibles, persistez vos cas de test en tant que Dataset d'évaluation MLflow:

Python

from mlflow.genai.datasets import create_dataset, get_dataset

# Create and populate a dataset
dataset = create_dataset(name="conversation_test_cases")
dataset.merge_records(
    [
        {"inputs": {"goal": "Successfully configure experiment tracking"}},
        {"inputs": {"goal": "Debug a deployment error", "persona": "Senior engineer"}},
    ]
)

# Use the dataset with the simulator
dataset = get_dataset(name="conversation_test_cases")
simulator = ConversationSimulator(test_cases=dataset)

Interface de fonction d'agent

Votre fonction d’agent reçoit l’historique des conversations et renvoie une réponse. Deux noms de paramètres sont pris en charge :

• input : Historique de conversation sous forme de liste de dictionnaires de messages (format de réponse des complétions de conversation)
• messages : Nom du paramètre alternatif équivalent (format de requête des achèvements de chat)

Python

def predict_fn(input: list[dict], **kwargs) -> str:
    """
    Args:
        input: Conversation history as a list of message dicts.
               Each message has "role" ("user" or "assistant") and "content".
               Alternatively, use "messages" as the parameter name.
        **kwargs: Additional arguments including:
            - mlflow_session_id: Unique ID for this conversation session
            - Any fields from your test case's "context"

    Returns:
        The assistant's response as a string.
    """

Basic

Python

from openai import OpenAI

client = OpenAI()


def predict_fn(input: list[dict], **kwargs):
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=input,
    )
    return response.choices[0].message.content

With context

Python

from openai import OpenAI

client = OpenAI()


def predict_fn(input: list[dict], **kwargs):
    # user_id is passed from test case's "context" field
    user_id = kwargs.get("user_id")

    # Customize system prompt based on context
    system_message = f"You are helping user {user_id}. Be helpful and concise."

    messages = [{"role": "system", "content": system_message}] + input

    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=messages,
    )
    return response.choices[0].message.content

Stateful agent

Pour les agents qui maintiennent un état entre les tours de conversation, utilisez le mlflow_session_id pour gérer l'état de la conversation :

Python

# Simple in-memory state management for stateful agents
conversation_state = {}  # Maps session_id -> conversation context


def predict_fn(input: list[dict], **kwargs):
    session_id = kwargs.get("mlflow_session_id")

    # Initialize or retrieve state for this session
    if session_id not in conversation_state:
        conversation_state[session_id] = {
            "turn_count": 0,
            "topics_discussed": [],
        }

    state = conversation_state[session_id]
    state["turn_count"] += 1

    # Your agent logic here - can use state for context
    system_message = f"You are a helpful assistant. This is turn {state['turn_count']} of the conversation."
    messages = [{"role": "system", "content": system_message}] + input

    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=messages,
    )

    return response.choices[0].message.content

Options de configuration

Paramètres de ConversationSimulator

parameter	Type	Par défaut	Description
test_cases	list[dict], DataFrame, ou EvaluationDataset	Obligatoire	Définitions de cas de test
max_turns	int	10	Nombre maximal de tours de conversation avant l’arrêt
user_model	str	(Hébergé sur Databricks)	Modèle de simulation des messages utilisateur
**user_llm_params	dict	{}	Paramètres supplémentaires pour le LLM de simulation utilisateur

parameter	Type	Par défaut	Description
test_cases	list[dict], DataFrame, ou EvaluationDataset	Obligatoire	Définitions de cas de test
max_turns	int	10	Nombre maximal de tours de conversation avant l’arrêt
user_model	str	(Hébergé sur Databricks)	Modèle de simulation des messages utilisateur
**user_llm_params	dict	{}	Paramètres supplémentaires pour le LLM de simulation utilisateur

Sélection du modèle

Le simulateur utilise un LLM pour générer des messages utilisateur réalistes. Vous pouvez spécifier un modèle différent en utilisant le user_model paramètre :

Python

simulator = ConversationSimulator(
    test_cases=test_cases,
    user_model="anthropic:/claude-sonnet-4-20250514",
    temperature=0.7,  # Passed to the user simulation LLM
)

Les formats de modèle pris en charge suivent le modèle "<provider>:/<model>". Consultez la documentation MLflow pour obtenir la liste complète des fournisseurs pris en charge.

Information sur les modèles alimentant la simulation de conversation

La simulation de conversation basée sur des LLM peut utiliser des services tiers pour simuler les interactions utilisateur, y compris Azure OpenAI opéré par Microsoft.

Pour Azure OpenAI, Databricks s'est désabonné du monitoring des abus, de sorte qu'aucune invite ou réponse n'est stockée avec Azure OpenAI.

Lorsque le traitement cross-Geo est désactivé, la simulation de conversation traite le contenu dans le Databricks Geo du Workspace. Si aucun modèle in-Geo éligible n'est disponible, la requête renvoie une erreur de restriction géographique. Lorsque le traitement cross-Geo est activé, la simulation de conversation peut traiter du contenu dans d'autres Geos.

La désactivation des fonctionnalités d'IA optimisées par les Partenaires empêche la simulation de conversation de faire appel aux modèles optimisés par les Partenaires. Vous pouvez toujours utiliser la simulation de conversation en fournissant votre propre modèle.

Arrêt de la conversation

Les conversations s'arrêtent lorsque l'une de ces conditions est remplie :

• Nombre maximal de tours atteint : la limite max_turns est atteinte
• Objectif atteint : le simulateur détecte que l'objectif de l'utilisateur a été atteint

Affichage des résultats

Les conversations simulées apparaissent dans l'interface utilisateur MLflow avec des métadonnées spéciales :

• ID de session : Chaque conversation dispose d'un ID de session unique (préfixé par sim-)
• Métadonnées de simulation : l'objectif, le persona et le numéro de tour sont stockés sur chaque trace

Accédez à l'onglet Sessions dans votre Experimentation pour afficher les conversations regroupées par session. Sélectionnez une session pour voir les tours individuels et leurs évaluations.

Ressources supplémentaires

• Évaluer les conversations – Découvrez l'évaluation statique des conversations et les scorers multi-tour.
• Évaluateurs prédéfinis – Explorez les évaluateurs prédéfinis pour la complétude de la conversation, la frustration de l’utilisateur, et plus encore.
• Jeux de données d’évaluation – Conservez vos cas de test dans des jeux de données d’évaluation pour des tests reproductibles.