Um guia para fluxos de trabalho multiagentes confiáveis%

À medida que a IA fica mais inteligente, os agentes agora lidam com tarefas complexas. As pessoas tomam decisões em fluxos de trabalho inteiros com muita eficiência e boas intenções, mas nunca com precisão perfeita. É fácil se desviar da tarefa, explicar demais, explicar mal, interpretar mal um immediate ou criar dores de cabeça para o que vier a seguir. Às vezes, o resultado acaba fora do assunto, incompleto ou até mesmo inseguro. E à medida que esses agentes começam a assumir o trabalho actual, precisamos de um mecanismo para verificar a sua produção antes de deixá-la prosseguir. Esta é apenas outra razão pela qual a CrewAI se ramificou no uso de proteções de tarefas. Os guardrails criam as mesmas expectativas para cada tarefa: duração, tom, qualidade, formato e precisão são esclarecidos por regras. Se o agente se desviar do guardrail, ele corrigirá suavemente o curso e forçará o agente a tentar novamente. Ele mantém estável o fluxo de trabalho. Guardrails ajudará os agentes a permanecerem no caminho certo, consistentes e confiáveis ​​do início ao fim.

O que são proteções de tarefas?

As proteções de tarefas são verificações de validação aplicadas a uma tarefa específica, no CrewAI. As proteções de tarefas são executadas imediatamente após um agente de IA concluir uma saída relacionada à tarefa. Uma vez que IA gera sua saída, se estiver em conformidade com suas regras, continuaremos a realizar a próxima ação em seu fluxo de trabalho. Caso contrário, interromperemos a execução ou tentaremos novamente de acordo com suas configurações.

Pense em um guarda-corpo como um filtro. O agente conclui seu trabalho, mas antes que esse trabalho tenha impacto em outras tarefas, o guardrail analisa o trabalho do agente. Segue o formato esperado? Inclui as palavras-chave necessárias? É tempo suficiente? É relevante? Atende aos critérios de segurança? Somente quando o trabalho for verificado em relação a esses parâmetros o fluxo de trabalho continuará.

Leia mais: Guarda-corpos em LLM

CrewAI tem dois tipos de proteções para ajudá-lo a garantir a conformidade com seus fluxos de trabalho:

1. Guarda-corpos baseados em funções

Esta é a abordagem usada com mais frequência. Você simplesmente escreve uma função em Pitão que verifica a saída do agente. A função retornará:

• Verdadeiro se a saída for válida
• Falso com suggestions opcional se a saída não for válida

As proteções baseadas em funções são mais adequadas para cenários baseados em regras, como:

• Contagem de palavras
• Frases obrigatórias
• Formatação JSON
• Validação de formato
• Verificando palavras-chave

Por exemplo, você pode dizer: “O resultado deve incluir as frases chaleira elétrica e ter pelo menos 150 palavras.”

2. Guarda-corpos baseados em LLM

Esses guarda-corpos utilizavam um LLM para avaliar se a saída de um agente satisfez alguns critérios menos rigorosos, tais como:

• Tom
• Estilo
• Criatividade
• Qualidade subjetiva
• Profissionalismo

Em vez de escrever o código, apenas forneça uma descrição de texto que possa ser: “Certifique-se de que a escrita seja amigável, não use gírias e pareça apropriada para o público em geral”. Em seguida, o modelo examinaria a saída e decidiria se ela seria aprovada ou não.

Ambos os tipos são poderosos. Você pode até combiná-los para obter validação em camadas.

Por que usar proteções de tarefas?

Existem proteções em fluxos de trabalho de IA por vários motivos importantes. Veja como eles são normalmente usados:

1. Controle de qualidade

Os resultados produzidos pela IA podem variar em qualidade, pois um immediate pode criar uma resposta excelente, enquanto o próximo erra totalmente o objetivo. Os guarda-corpos ajudam a controlar a qualidade da produção porque os guarda-corpos criam a expectativa de padrões mínimos de produção. Se um resultado for muito curto, não relacionado à solicitação ou mal organizado, a proteção garante que ações serão tomadas.

2. Segurança e Conformidade

Alguns fluxos de trabalho exigem precisão estrita. Essa regra prática é especialmente verdadeira quando se trabalha em casos de uso de saúde, finanças, jurídico ou empresarial. As proteções são usadas para evitar alucinações e resultados de conformidade inseguros que violam as diretrizes. CrewAI possui uma ‘proteção de alucinação’ integrada que busca conteúdo baseado em fatos para aumentar a segurança.

3. Confiabilidade e Previsibilidade

Em fluxos de trabalho de várias etapas, uma saída incorreta pode causar a quebra de tudo no fluxo posterior. Uma saída mal formada para uma consulta pode causar falha na consulta de outro agente. Guardrails protegem contra saídas inválidas, estabelecendo pipelines confiáveis ​​e previsíveis.

4. Lógica de nova tentativa automatizada

Se você não quiser lidar com a correção guide das saídas, você pode fazer com que o CrewAI tente novamente automaticamente. Se a proteção falhar, permita que a CrewAI tente enviar as informações novamente até mais duas vezes. Esse recurso cria fluxos de trabalho resilientes e reduz a quantidade de supervisão necessária durante um fluxo de trabalho.

Como funcionam as proteções de tarefas?

As proteções de tarefas da CrewAI oferecem um processo simples, mas poderoso. O agente executa a tarefa e gera a saída, então o guardrail é ativado e recebe a saída. O guardrail verifica a saída com base nas regras que você configurou. Se o resultado da saída passar na verificação do guardrail, o fluxo de trabalho continua. Se o resultado da saída não passar na verificação do guardrail, o guardrail tentará acionar uma nova tentativa ou gerará um erro. Você pode personalizar novas tentativas definindo o máximo de tentativas, intervalos de repetição e mensagens personalizadas. CrewAI registra cada tentativa e fornece visibilidade exatamente do que aconteceu em cada etapa do fluxo de trabalho. Esse loop ajuda a garantir que o sistema permaneça estável, oferece o benefício de maior precisão e torna o fluxo de trabalho mais confiável em geral.

Principais recursos e práticas recomendadas

Função vs guarda-corpos LLM

Implemente proteções baseadas em funções para regras explícitas. Implemente guarda-corpos baseados em LLM para junções possivelmente subjetivas.

Guarda-corpos de encadeamento

Você é capaz de executar vários guarda-corpos.

1. Verificação de comprimento
2. Verificação de palavras-chave
3. Verificação de tom
4. Verificação de formato

O fluxo de trabalho continua caso todos sejam aprovados.

Guarda-corpo de alucinação

Para fluxos de trabalho mais baseados em fatos, use a proteção de alucinação integrada do CrewAI. Ele compara a saída com a referência de contexto e detecta se sinalizou declarações não suportadas.

Estratégias de repetição

Defina limites para suas novas tentativas com cuidado. Menos tentativas = fluxo de trabalho rigoroso, mais tentativas = mais criatividade.

Registro e observabilidade

CrewAI mostra:

• O que falhou
• Por que falhou
• Qual tentativa teve sucesso

Isso pode ajudá-lo a ajustar suas grades de proteção.

Exemplo prático: validando a descrição de um produto

Neste exemplo, demonstramos como um guardrail verifica a descrição do produto antes de aceitá-lo. As expectativas são claras. A descrição do produto deve ter no mínimo 150 palavras, conter a expressão “chaleira elétrica” e seguir o formato exigido.

Etapa 1: configuração e importação

Nesta etapa, instalamos o CrewAI, importamos a biblioteca e carregamos as chaves API. Isso permite configurar adequadamente todas as variáveis ​​para que o agente possa executar e conectar-se de forma assíncrona às ferramentas necessárias.

%pip set up -U -q crewai crewai-tools

from crewai import Agent, Job, LLM, Crew, TaskOutput
from crewai_tools import SerperDevTool
from datetime import date
from typing import Tuple, Any
import os, getpass, warnings

warnings.filterwarnings("ignore")

SERPER_API_KEY = getpass.getpass('Enter your SERPER_API_KEY: ')
OPENAI_API_KEY = getpass.getpass('Enter your OPENAI_API_KEY: ')

if SERPER_API_KEY and OPENAI_API_KEY:
    os.environ('SERPER_API_KEY') = SERPER_API_KEY
    os.environ('OPENAI_API_KEY') = OPENAI_API_KEY

print("API keys set efficiently!")

Etapa 2: Definir a função Guardrail

A seguir, você outline uma função que valida a saída do agente. Ele pode verificar se a saída contém “chaleira elétrica” e contar o whole de palavras de saída. Se não encontrar o texto esperado ou se a saída for muito curta, ele retornará a resposta de falha. Se a descrição for exibida corretamente, ela retornará sucesso.

def validate_product_description(outcome: TaskOutput) -> Tuple(bool, Any):
    textual content = outcome.uncooked.decrease().strip()
    word_count = len(textual content.cut up())

    if "electrical kettle" not in textual content:
        return (False, "Lacking required phrase: 'electrical kettle'")
    if word_count < 150:
        return (False, f"Description too brief ({word_count} phrases). Should be at the least 150.")
    return (True, outcome.uncooked.strip())

Etapa 3: definir agente e tarefa

Finalmente, você outline o Agente que criou para escrever a descrição. Você atribui a ele uma função e um objetivo. Em seguida, você outline a tarefa e adiciona a proteção à tarefa. A tarefa será repetida até três vezes se a saída do agente falhar.

llm = LLM(mannequin="gpt-4o-mini", api_key=OPENAI_API_KEY)

product_writer = Agent(
position="Product Copywriter",
aim="Write high-quality product descriptions",
backstory="An skilled marketer expert in persuasive descriptions.",
instruments=(SerperDevTool()),
    llm=llm,
verbose=True
)

product_task = Job(
description="Write an in depth product description for {product_name}.",
    expected_output="A 150+ phrase description mentioning the product title.",
agent=product_writer,
markdown=True,
guardrail=validate_product_description,
    max_retries=3
)

crew = Crew(
brokers=(product_writer),
duties=(product_task),
verbose=True
)

Etapa 4: execute o fluxo de trabalho

Você inicia a tarefa. O agente compõe a descrição do produto. O guardrail avalia isso. Se a avaliação falhar, o agente cria uma nova descrição. Isso continua até que a saída passe no processo de avaliação ou até que o número máximo de iterações seja concluído.

outcomes = crew.kickoff(inputs={"product_name": "electrical kettle"}) 

print("n Ultimate Abstract:n", outcomes)

Etapa 5: exibir a saída

No closing, você mostrará a saída correta que passou nas verificações de proteção. Esta é a descrição validada do produto que atende a todos os requisitos.

from IPython.show import show, Markdown
show(Markdown(outcomes.uncooked))

Algumas sugestões práticas

• Seja muito claro em seu expected_output.
• Não faça grades de proteção muito rígidas.
• Registre os motivos da falha.
• Use guarda-corpos com antecedência para evitar danos a jusante.
• Teste casos extremos.

Guardrails devem proteger seu fluxo de trabalho, não bloqueá-lo.

Leia mais: Construindo Agentes de IA com CrewAI

Conclusão

As proteções de tarefas são simplesmente um dos recursos mais importantes do CrewAI. Os Guardrails garantem segurança, precisão e consistência em fluxos de trabalho multiagentes. Guardrails validam as saídas antes que elas se movam para baixo; portanto, eles são o recurso elementary para ajudar a criar sistemas de IA que são simplesmente poderosos e precisos. Seja construindo um gravador automatizado, um pipeline de análise ou uma estrutura de decisão, os guardrails criam uma camada de qualidade que ajuda a manter tudo alinhado. Em última análise, as proteções garantem que o processo de automação seja mais suave, seguro e previsível do início ao fim.

Perguntas frequentes

Olá, sou Janvi, um entusiasta apaixonado pela ciência de dados que atualmente trabalha na Analytics Vidhya. Minha jornada no mundo dos dados começou com uma profunda curiosidade sobre como podemos extrair insights significativos de conjuntos de dados complexos.