TerminalSkills/skills

AG2 (AutoGen) — Framework de Conversação Multiagente

Você é um especialista em AG2 (antigo AutoGen), o framework de conversação multiagente de código aberto. Você ajuda desenvolvedores a construir sistemas onde múltiplos agentes de IA colaboram através de conversas estruturadas — com uso de ferramentas, supervisão humana, execução de código, orquestração de chat em grupo e conversas aninhadas — para tarefas complexas como desenvolvimento de software, pesquisa e análise de dados.

Capacidades Principais

Conversa entre Dois Agentes

from autogen import ConversableAgent, UserProxyAgent

# Agente assistente de IA
assistant = ConversableAgent(
    name="Engenheiro",
    system_message="""Você é um engenheiro de software sênior.
    Escreva código Python limpo e testado. Explique suas decisões de design.""",
    llm_config={"model": "gpt-4o", "temperature": 0.2},
)

# Proxy humano (pode auto-aprovar ou exigir entrada humana)
user_proxy = UserProxyAgent(
    name="Usuário",
    human_input_mode="NEVER",             # NEVER / ALWAYS / TERMINATE
    max_consecutive_auto_reply=10,
    is_termination_msg=lambda msg: "TERMINATE" in msg.get("content", ""),
    code_execution_config={
        "work_dir": "workspace",
        "use_docker": True,               # Execução segura de código em Docker
    },
)

# Iniciar conversa — agentes conversam até a tarefa ser concluída
result = user_proxy.initiate_chat(
    assistant,
    message="Crie um app FastAPI com autenticação de usuário usando JWT. Inclua testes.",
)
# Engenheiro escreve código → Proxy de usuário executa → Engenheiro revisa saída → itera

Chat em Grupo (Múltiplos Agentes)

from autogen import GroupChat, GroupChatManager

# Agentes especialistas
architect = ConversableAgent(
    name="Arquiteto",
    system_message="Você projeta arquitetura de sistemas. Foco em escalabilidade, confiabilidade e interfaces limpas.",
    llm_config={"model": "gpt-4o"},
)

desenvolvedor = ConversableAgent(
    name="Desenvolvedor",
    system_message="Você implementa funcionalidades baseadas no design do arquiteto. Escreva código de qualidade de produção.",
    llm_config={"model": "gpt-4o"},
)

revisor = ConversableAgent(
    name="Revisor",
    system_message="Você revisa código em busca de bugs, problemas de segurança e boas práticas. Seja minucioso, mas construtivo.",
    llm_config={"model": "gpt-4o"},
)

testador = ConversableAgent(
    name="Testador",
    system_message="Você escreve testes abrangentes. Cubra casos extremos e cenários de integração.",
    llm_config={"model": "gpt-4o"},
)

# Chat em grupo com seleção de orador round-robin ou por IA
chat_grupo = GroupChat(
    agents=[user_proxy, arquiteto, desenvolvedor, revisor, testador],
    messages=[],
    max_round=20,
    speaker_selection_method="auto",      # LLM escolhe o próximo orador com base no contexto
)

gerenciador = GroupChatManager(groupchat=chat_grupo, llm_config={"model": "gpt-4o"})

user_proxy.initiate_chat(
    gerenciador,
    message="Construa um serviço de notificações em tempo real com suporte a WebSocket, pub/sub Redis e limitação de taxa.",
)
# Arquiteto projeta → Desenvolvedor implementa → Revisor captura problemas → Desenvolvedor corrige → Testador adiciona testes

Uso de Ferramentas

from autogen import register_function

def buscar_codigo(consulta: str, padrao_arquivo: str = "*.py") -> str:
    """Busca padrões específicos na base de código.

    Args:
        consulta: Consulta de busca (regex suportado)
        padrao_arquivo: Padrão glob de arquivos para buscar
    """
    import subprocess
    resultado = subprocess.run(["grep", "-rn", consulta, "--include", padrao_arquivo, "."],
                           capture_output=True, text=True)
    return resultado.stdout[:2000]

def executar_testes(caminho_teste: str = "tests/") -> str:
    """Executa pytest no diretório de teste especificado.

    Args:
        caminho_teste: Caminho para arquivos de teste ou diretório
    """
    import subprocess
    resultado = subprocess.run(["python", "-m", "pytest", caminho_teste, "-v", "--tb=short"],
                           capture_output=True, text=True)
    return f"STDOUT:\n{resultado.stdout}\nSTDERR:\n{resultado.stderr}"

# Registrar ferramentas para agentes específicos
register_function(buscar_codigo, caller=desenvolvedor, executor=user_proxy,
    description="Busca na base de código por padrões de código")
register_function(executar_testes, caller=testador, executor=user_proxy,
    description="Executa testes para verificar a correção do código")

Instalação

pip install ag2                           # Ou: pip install pyautogen

Melhores Práticas

1. Mensagens de sistema claras — Defina o papel de cada agente com precisão; instruções vagas levam a conversas sem foco
2. Seleção de orador — Use auto para seleção de orador por LLM em chat em grupo; round_robin para fluxo previsível
3. Condições de término — Defina is_termination_msg e max_consecutive_auto_reply; evite loops infinitos
4. Docker para execução de código — Ative use_docker: True para execução segura de código; agentes podem executar código não confiável
5. Supervisão humana — Use o modo TERMINATE para aprovação em ações críticas; NEVER para totalmente autônomo
6. Registro de ferramentas — Registre ferramentas com pares específicos de chamador/executor; nem todos os agentes precisam de todas as ferramentas
7. Chats aninhados — Use conversas aninhadas para subtarefas; o agente pode iniciar uma conversa paralela e retornar resultados
8. Controle de custos — Defina max_round e max_consecutive_auto_reply; monitore o uso de tokens em chats em grupo