Simulação de conversa

A simulação de conversação permite gerar conversas sintéticas com múltiplas interações para testar seus agentes AI conversacionais. Em vez de criar manualmente conversas de teste ou esperar por dados de produção, você pode definir cenários de teste e deixar o MLflow simular automaticamente interações realistas do usuário.

nota

A simulação de conversação é experimental. A API e o comportamento podem mudar em versões futuras.

Pré-requisitos

Instale o MLflow 3.10.0 ou mais tarde:

Bash

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

Por que simular conversas?

Aspecto	Dados de teste manual	Simulação de conversa
Teste de versão	Não é possível testar novamente novas versões do agente com as mesmas conversas.	Reproduza cenários idênticos em diferentes versões do agente.
Cobertura	Limitado pela criatividade humana e pelo tempo.	Gere diversos casos extremos em escala.
Consistência	Variações na criação de testes manuais	Cenários de teste reproduzíveis com objetivos definidos
Escala	A criação de muitos casos de teste consome muito tempo.	Gere centenas de conversas instantaneamente
Manutenção	É necessário atualizar manualmente os dados de teste.	Recriar conversas quando os requisitos mudarem

A simulação de conversas aborda esses desafios gerando conversas programaticamente com base em objetivos e personas definidos, permitindo:

• Avaliação sistemática : Testar diferentes versões do agente com objetivos e personas consistentes.
• Red-teaming : Teste de estresse em agentes com diversos comportamentos de usuário em larga escala.
• Iteração rápida : gere novas conversas de teste instantaneamente quando os requisitos mudarem.

fluxo de trabalho

1. Defina casos de teste ou extraia informações de conversas existentes — especifique objetivos, personas e contexto para cada conversa simulada ou gere-os a partir de sessões de produção.
2. Criar simulador - Inicializar ConversationSimulator com seus casos de teste e configuração.
3. Defina seu agente - Implemente seu agente em uma função que aceite o histórico da conversa.
4. Avaliação de execução - Passe o simulador para mlflow.genai.evaluate() com seus avaliadores.

Comece rápido

Aqui está um exemplo completo que simula conversas e as avalia:

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)
    ],
)

Definindo casos de teste

Cada caso de teste representa um cenário de conversa. Os casos de teste abrangem três áreas:

campo	Obrigatório	Descrição
goal	Sim	O que o usuário simulado está tentando realizar
persona	Não	Descrição da personalidade e do estilo de comunicação do usuário.
context	Não	Argumentos nomeados adicionais passados para sua função de previsão.

Meta

O objetivo descreve o que o usuário simulado deseja alcançar. Deve ser específico o suficiente para orientar a conversa, mas também aberto o bastante para permitir um diálogo natural. Bons objetivos descrevem o resultado esperado, para que o simulador saiba quando a intenção do usuário foi alcançada:

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

Persona

A persona define a forma como o usuário simulado se comunica. Caso não seja especificado, será utilizada uma persona de utilizador prestável default :

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

Contexto

O campo de contexto passa parâmetros adicionais para sua função de previsão. Isso é útil para:

• Transmissão de identificadores de usuário para personalização.
• Fornecer o estado ou a configuração da sessão.
• Incluindo os metadados que seu agente precisa.

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

Defina os casos de teste.

A maneira mais simples de definir casos de teste é como uma lista de dicionários ou um 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)

Você também pode usar um 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)

Gere casos de teste a partir de conversas existentes.

Gere casos de teste a partir de sessões de conversa existentes usando generate_test_cases. Isso é útil para criar casos de teste que reflitam o comportamento real do usuário a partir de conversas em produção:

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)

Acompanhe os casos de teste como dataset MLflow

Para testes reproduzíveis, persista seus casos de teste como um conjunto de dados de avaliaçãoMLflow:

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 função do agente

Sua função de agente recebe o histórico da conversa e retorna uma resposta. São suportados dois nomes de parâmetros:

• input : Histórico da conversa como uma lista de dicionários de mensagens (formato de resposta de conclusões de bate-papo)
• messages : Nome de parâmetro alternativo equivalente (formato de solicitação de conclusões de bate-papo)

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

Para agentes que mantêm o estado entre turnos, use mlflow_session_id para gerenciar o estado da conversa:

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

Opções de configuração

Parâmetros do Simulador de Conversação

Parâmetro	Tipo	Padrão	Descrição
test_cases	list[dict], DataFrame, ou EvaluationDataset	Obrigatório	Definições de casos de teste
max_turns	int	10	Número máximo de turnos de conversa antes de parar
user_model	str	(Hospedado no Databricks)	Modelo para simulação de mensagens de usuário
**user_llm_params	dict	{}	Parâmetros adicionais para a simulação do usuário LLM

Seleção de modelo

O simulador utiliza um modelo de linguagem latente (LLM) para gerar mensagens de usuário realistas. Você pode especificar um modelo diferente usando o parâmetro user_model :

Python

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

Os formatos de modelo suportados seguem o padrão "<provider>:/<model>". Consulte a documentação do MLflow para obter a lista completa de provedores compatíveis.

Informações sobre os modelos que alimentam a simulação de conversas.

A simulação de conversas baseada em LLMpode usar serviços de terceiros para simular interações do usuário, incluindo Azure OpenAI operado pela Microsoft.

Para o Azure OpenAI, a Databricks optou por não utilizar o Abuse Monitoring, portanto nenhum prompt ou resposta é armazenado com o Azure OpenAI.

Para o espaço de trabalho da União Europeia (UE), a simulação de conversas utiliza modelos hospedados na UE. Todas as outras regiões usam modelos hospedados nos EUA.

Desativar o recurso AI baseado em parceiros impede que a simulação de conversas chame modelos baseados em parceiros. Você ainda pode usar a simulação de conversação fornecendo seu próprio modelo.

A conversa foi interrompida.

As conversas são interrompidas quando qualquer uma destas condições for atendida:

• Número máximo de turnos atingido : O limite max_turns foi atingido
• Objetivo alcançado : O simulador detecta que o objetivo do usuário foi atingido.

Resultados da visualização

As conversas simuladas aparecem na interface do usuário do MLflow com metadados especiais:

• ID da sessão : Cada conversa tem um ID de sessão único (prefixado com sim-)
• Metadados da simulação : Objetivo, personagem e número da rodada são armazenados em cada registro.

Acesse a tab Sessões em seu experimento para view as conversas agrupadas por sessão. Selecione uma sessão para ver as intervenções individuais e suas respectivas avaliações.

Próximos passos

• Avalie conversas - Aprenda sobre avaliação estática de conversas e avaliadores de múltiplas interações.
• Pontuadores predefinidos - Explore os pontuadores predefinidos para avaliar a completude da conversa, a frustração do usuário e muito mais.
• Conjunto de dados de avaliação - Armazene seus casos de teste no conjunto de dados de avaliação para testes reproduzíveis.