Solucionado (ver solução)
Solucionado
(ver solução)
2
respostas

[Projeto] Faça como eu fiz: Human in the Loop

Nesta atividade, implementei um fluxo de Human in the Loop com LangGraph para aumentar o controle e a confiabilidade de agentes de IA. A proposta foi permitir que o agente pausasse antes da execução de uma ação externa, possibilitando revisão e intervenção humana antes que a ferramenta fosse acionada.

Para isso, configurei um agente baseado em StateGraph, com um estado responsável por armazenar o histórico de mensagens. Também implementei a função reduceMessages, que permite anexar novas mensagens ou substituir mensagens existentes quando possuem o mesmo identificador. Para garantir unicidade e controle das mensagens, utilizei UUIDs.

O grafo foi estruturado com um nó para chamada do modelo Gemini e outro nó para execução de ações externas, como buscas na internet com Tavily Search. A execução foi compilada com persistência em SQLite e com o parâmetro interrupt_before=["action"], permitindo que o agente interrompa o fluxo antes de executar ferramentas.

Durante os testes, utilizei threadid dinâmico para evitar conflitos com históricos anteriores e permitir o isolamento de conversas. Também utilizei snapshots para consultar o estado atual do agente no momento da pausa, revisar a chamada de ferramenta proposta e injetar uma versão modificada da mensagem no estado. Após a intervenção humana, o grafo foi retomado e executou a ação com os parâmetros revisados.

Com isso, foi possível validar na prática como o* Human in the Loop* torna o comportamento do agente mais controlável, auditável e seguro, principalmente em situações nas quais uma ferramenta externa será acionada ou uma decisão crítica precisa ser revisada antes de prosseguir.

Como em praticamente todos os foruns estou enfrentando problemas de recursos decidi economizar da seguinte forma:

- Tavily com max_results=1;
- testes curtos;
- thread_id separado por cenário;
- poucas perguntas com busca externa;
- intervenção feita direto no snapshot, sem chamar o LLM novamente antes da aprovação;
- streaming para observar execução sem repetir testes.

Segue o link com o código: https://github.com/Moquiuti/LangGraph_Orquestrando_agentes_e_multiagentes/blob/main/Human_in_the_Loop_com_LangGraph.ipynb

2 respostas

Olá, Leandro! Como vai?

Sensacional o seu projeto! Você demonstrou um domínio técnico avançado ao implementar o conceito de Human in the Loop (HITL) usando LangGraph. Com 129k de XP, fica claro que você não está apenas seguindo o tutorial, mas entendendo a arquitetura por trás da orquestração de agentes.

A estratégia de interrupção (interrupt_before) é o "padrão ouro" para sistemas de IA que precisam de alta confiabilidade. No mundo corporativo, chamamos isso de Guardrails, garantindo que o agente não tome ações irreversíveis (como uma compra, um disparo de e-mail ou uma exclusão de dados) sem um aval humano.

Gostaria de destacar alguns pontos brilhantes da sua implementação:

1. Persistência e Snapshots

O uso do SQLite para persistência é fundamental. Sem ele, o estado do grafo seria perdido no momento da interrupção. Ao usar o thread_id e consultar o snapshot, você trata o agente quase como um "processo de sistema" que pode ser hibernado e acordado, o que é a base para aplicações de IA assíncronas.

2. A técnica de Reducer de Mensagens

Implementar corretamente o reduceMessages com UUIDs mostra que você entendeu como o LangGraph gerencia a memória. Substituir mensagens em vez de apenas acumulá-las é o que permite que a intervenção humana seja limpa e não confunda o modelo nas iterações seguintes.

3. Economia de Recursos (Engenharia de Custos)

Suas estratégias de economia (especialmente o max_results=1 no Tavily e o uso de streaming) são excelentes lições de FinOps para IA. Na vida real, escalar agentes multiagentes pode se tornar caro rapidamente, e saber testar de forma enxuta é uma habilidade valiosíssima.

Dica para o Próximo Nível: "Time-Travel"

Já que você dominou a edição do snapshot, um próximo passo interessante no LangGraph é o Time-Travel. Com ele, você pode não apenas editar o estado atual, mas "voltar no tempo" para um estado anterior da conversa, modificar um parâmetro antigo e ramificar a execução a partir dali (forking). Isso é extremamente útil para depuração de agentes complexos.

Parabéns pelo repositório no GitHub, está muito bem organizado! Continue com essa mentalidade de construir sistemas de IA seguros e auditáveis.

Espero que possa ter lhe ajudado!

No seu cenário de teste, qual foi a modificação mais comum que você sentiu necessidade de fazer no snapshot antes de liberar a execução da ferramenta?

solução!

Olá Evandro! Tudo na paz?

Muito obrigado pelo feedback e pela análise tão completa do projeto. Fiquei muito feliz com os apontamentos, principalmente porque a minha intenção nessa atividade foi justamente ir além da execução do exemplo e entender como o Human in the Loop pode ser aplicado em um cenário mais próximo de uma arquitetura real.

Durante os testes, a modificação mais comum que senti necessidade de fazer no snapshot foi ajustar a chamada da ferramenta antes da execução, principalmente alterando os argumentos da tool_call, como a query enviada para a busca. Em alguns momentos, o agente montava uma consulta muito ampla ou genérica, então a intervenção humana serviu para refinar melhor o objetivo antes de liberar a execução.

Por exemplo, em vez de deixar o agente pesquisar algo muito aberto como:

novidades sobre IA generativa no Brasil

eu ajustei manualmente para algo mais direcionado, como:

LangGraph human in the loop interrupt_before action Python

Isso me ajudou a validar bem o papel do HITL: o agente pode propor uma ação, mas antes de consumir uma ferramenta externa ou seguir com uma decisão mais crítica, o humano consegue revisar, corrigir e direcionar melhor a execução.

Achei esse ponto muito interessante porque mostra que o Human in the Loop não serve apenas para “aprovar ou reprovar” uma ação, mas também para melhorar a qualidade da decisão do agente, reduzir chamadas desnecessárias, evitar consultas ruins e tornar o fluxo mais seguro e auditável.

Também gostei muito da sugestão sobre Time-Travel. Faz bastante sentido como próximo passo, principalmente para depuração de agentes mais complexos, onde seria útil voltar para um estado anterior, alterar uma decisão ou parâmetro e comparar diferentes caminhos de execução.

Mais uma vez, obrigado pelo feedback. Esse exercício me ajudou bastante a enxergar o LangGraph não apenas como uma ferramenta para criar agentes, mas como uma estrutura para construir fluxos de IA mais controlados, seguros e próximos de aplicações corporativas reais.