Skip to article frontmatterSkip to article content
Site not loading correctly?

This may be due to an incorrect BASE_URL configuration. See the MyST Documentation for reference.

Frameworks de Orquestração e Multi-agentes

O crescimento da Inteligência Artificial trouxe consigo um ecossistema diverso de ferramentas e frameworks, que aceleram a criação, teste e implantação de soluções. Esses recursos permitem que equipes foquem no valor de negócio em vez de reinventar a roda do zero.

Neste capítulo, vamos explorar algumas das ferramentas mais utilizadas atualmente, com foco em suas aplicações práticas, pontos fortes e limitações.

LangChain

O surgimento dos Modelos de Linguagem de Grande Escala (LLMs) marcou uma virada no desenvolvimento de software, levando as aplicações de simples respostas transacionais a sistemas cognitivos, capazes de compreender, raciocinar e agir com autonomia.

Essa evolução trouxe uma nova camada de complexidade — a orquestração. Agora, não basta fazer uma única chamada a um modelo:

Antes dos frameworks especializados, os desenvolvedores precisavam gerenciar tudo manualmente, criando um código “cola” frágil, difícil de manter e propenso a erros.

Nesse cenário, o LangChain surge como um ecossistema de orquestração que simplifica a criação de workflows complexos e multiagentes. Desta forma, o LangChain é uma das bibliotecas mais populares para desenvolvimento de aplicações baseadas em LLMs.

Ela oferece componentes reutilizáveis e modulares para:

from langchain.agents import Tool, AgentExecutor, LLMSingleActionAgent
from langchain.memory import ConversationBufferMemory

# Exemplo básico de configuração de um agente
tools = [
    Tool(
        name="Search",
        func=search_function,
        description="Útil para buscar informações"
    )
]

memory = ConversationBufferMemory()
agent = LLMSingleActionAgent(tools=tools, memory=memory)
agent_executor = AgentExecutor.from_agent_and_tools(
    agent=agent,
    tools=tools,
    memory=memory
)

É importante observar que, embora o LangChain seja um dos frameworks mais populares para orquestração de fluxos com LLMs, ele não está sozinho nesse ecossistema. Outras ferramentas também oferecem recursos avançados para construção de aplicações cognitivas:

Esses frameworks possuem focos distintos, mas compartilham o mesmo propósito: reduzir a complexidade do desenvolvimento de soluções baseadas em LLMs e acelerar a criação de sistemas robustos, modulares e inteligentes.

A Filosofia de Orquestração do LangChain: De Framework a Ecossistema

O LangChain é mais do que uma simples biblioteca; é um ecossistema abrangente projetado para gerir todo o ciclo de vida de uma aplicação alimentada por LLM, desde o desenvolvimento e produção até à implementação. A sua principal proposta de valor reside na abstração da complexidade inerente à interação com LLMs, fontes de dados e serviços externos, fornecendo uma interface padronizada e modular. Esta abordagem permite que os programadores construam rapidamente protótipos e iterem em aplicações complexas, como chatbots inteligentes, sistemas de perguntas e respostas sofisticados e ferramentas de análise de dados automatizadas.

A evolução da arquitetura do LangChain é um testemunho da sua maturidade e resposta às necessidades da comunidade de programadores. O que começou como um framework mais monolítico transformou-se num ecossistema modular e extensível. Esta mudança não é meramente organizacional; representa uma alteração estratégica fundamental. A estrutura atual está deliberadamente desagregada em pacotes distintos, cada um com um propósito claro:

Esta modularidade aborda diretamente o “inferno de dependências” (dependency hell) e a percepção de que o framework era excessivamente “inchado”. Ao incentivar novas integrações a serem publicadas como pacotes langchain-* separados, o ecossistema promove uma melhor gestão de dependências e versionamento. Esta evolução posiciona o langchain-core como um sistema nervoso central estável, sobre o qual um universo de ferramentas e integrações especializadas pode ser construído, permitindo que os programadores instalem apenas o que necessitam para criar aplicações mais leves e eficientes.

O Kit de Ferramentas do Programador: Componentes Fundamentais do LangChain

Para construir uma aplicação com o LangChain, um programador utiliza um conjunto de blocos de construção modulares. A compreensão de cada um destes componentes e da forma como interagem é crucial.

O Ponto de Conexão: Integrando Código Personalizado via Ferramentas (Tools)

A verdadeira potência do LangChain para um programador reside na sua capacidade de estender as capacidades de um LLM para além da geração de texto, permitindo-lhe interagir com o mundo exterior. O mecanismo principal para esta extensão é a criação de Ferramentas (Tools).

Uma ferramenta pode ser praticamente qualquer lógica de negócio encapsulada: uma função Python para consultar o inventário de produtos num sistema ERP, uma chamada a uma API externa para enviar um email de marketing, ou a execução de um script de análise financeira proprietário. Ao expor esta lógica como uma ferramenta, um agente LangChain pode decidir autonomamente quando e como utilizá-la.

O LangChain oferece vários métodos para criar ferramentas personalizadas, desde simples decoradores de função até implementações mais complexas. A chave para o sucesso é fornecer ao LLM uma descrição em linguagem natural clara e precisa da ferramenta, incluindo o que ela faz e quais são os seus parâmetros de entrada. É essa descrição que o LLM utiliza para raciocinar sobre a utilidade da ferramenta no contexto de uma determinada tarefa. Esta capacidade de integrar código personalizado transforma o LLM de um mero gerador de texto num verdadeiro orquestrador de processos de negócio.

Informações Adicionais do LangChain

A integração de código personalizado constitui apenas o primeiro passo na jornada para a criação de aplicações de IA de nível de produção. A orquestração de agentes, por exemplo, introduz desafios de controlo e fiabilidade que não podem ser adequadamente resolvidos com as sequências lineares das Chains tradicionais.

Esta limitação expõe a necessidade de um paradigma de orquestração mais avançado: o LangGraph. Conforme será explorado em detalhe posteriormente, o LangGraph foi projetado especificamente para construir agentes mais robustos e controláveis, permitindo a criação de fluxos de trabalho com ciclos, ramificações condicionais e a capacidade de auto-correção; capacidades essenciais para sistemas autónomos complexos.

A transição do modelo de Chains para a arquitetura de grafos do LangGraph é, portanto, o que distingue a criação de um protótipo funcional da engenharia de um sistema de IA de real valor comercial. Com a base da integração de ferramentas solidamente estabelecida, o terreno está preparado para a exploração de arquiteturas avançadas que transformam o potencial da IA em realidade de negócio.

LangFlow

O LangFlow é uma interface visual que facilita a construção de aplicações com modelos de linguagem. É uma ferramenta de código aberto, desenvolvida em Python, que funciona como um “laboratório de fluxos”, no qual prompts, APIs, bancos de dados e lógica de negócio podem ser conectados de forma intuitiva, sem necessidade de programação aprofundada. Por reduzir barreiras técnicas, é especialmente útil para equipes multidisciplinares (como marketing e inovação) que querem experimentar IA de forma ágil LangFlow (2023). É ideal para prototipagem rápida de aplicações de IA e experimentação com diferentes modelos e arquiteturas de fluxo.

O LangFlow pode ser enquadrado não apenas como uma ferramenta, mas como um paradigma de desenvolvimento distinto.

História por trás do LangFlow

A plataforma foi desenvolvida pela empresa Logspace, fundada em 2022 pelos mineiros (🔺) Rodrigo Nader e Gabriel Almeida. Em entrevistas e publicações, o projeto é frequentemente descrito como uma “ferramenta brasileira”.

Rodrigo Nader, um dos fundadores, expressou o objetivo de fortalecer o cenário de tecnologia no país, afirmando:

“Nosso objetivo é transformar o Brasil em um polo de inovação em inteligência artificial”.

Posteriormente, a empresa foi adquirida pela DataStax, que agora faz parte da IBM.

Definindo o LangFlow: Além de uma UI para o LangChain

O LangFlow é uma plataforma visual de código aberto que simplifica a criação de aplicações com Geração Aumentada por Recuperação (RAG) e estruturas baseadas em múltiplos agentes. Seu grande diferencial está na interface intuitiva de arrastar e soltar, que substitui a escrita de código tradicional por uma experiência acessível e visual. Assim, mesmo quem não domina programação pode construir fluxos de trabalho inteligentes com facilidade.

Embora tenha surgido como uma simples interface gráfica para o LangChain, o LangFlow evoluiu rapidamente. Hoje, ele se consolidou como uma ferramenta poderosa para prototipagem e experimentação ágil de sistemas de IA. Graças à sua abordagem visual, a plataforma derruba barreiras técnicas e convida até mesmo usuários iniciantes — ou de áreas não técnicas — a explorarem o desenvolvimento de soluções complexas com IA.

Outro ponto forte do LangFlow é sua flexibilidade tecnológica. Ele é totalmente agnóstico em relação a LLMs e bancos de vetores, o que significa que oferece suporte aos principais provedores do mercado. Além disso, conta com uma biblioteca crescente de componentes e integrações. Isso garante ao desenvolvedor a liberdade de escolher os melhores recursos para cada projeto, sem se prender a uma tecnologia ou fornecedor específico.

Acelerando o Ciclo de Vida do Desenvolvimento de IA

O LangFlow aborda diretamente a natureza lenta e intensiva em código da prototipagem de aplicações de LLM. A plataforma permite que os desenvolvedores “parem de lutar com as suas ferramentas” e se concentrem em criar “magia de IA”.

Ao visualizar os workflows, facilita a colaboração e torna ideias de produtos complexas compreensíveis tanto para os stakeholders técnicos como para os não técnicos. Esta clareza visual é um diferenciador chave, permitindo que as equipas construam e demonstrem workflows de LLM rapidamente.

A plataforma democratiza o acesso a conceitos poderosos de IA, como agentes, RAG e orquestração de múltiplas ferramentas, tornando-os tangíveis e manipuláveis sem a necessidade de um conhecimento profundo em programação. Essencialmente, o LangFlow acelera o ciclo de vida do desenvolvimento de IA ao permitir que as equipas transformem rapidamente ideias em protótipos funcionais, testem diferentes configurações e iterem sobre a lógica da aplicação com um esforço mínimo.

A natureza visual do LangFlow traz benefícios que vão além da aceleração do desenvolvimento individual. Ela transforma a dinâmica colaborativa em equipes multidisciplinares e reduz falhas de comunicação entre áreas técnicas e de negócio.

Impacto na Colaboração em Equipes Híbridas: O desenvolvimento de soluções com IA exige cada vez mais uma atuação integrada entre diversos perfis profissionais:

Engenheiros de software

Cientistas de dados

Gestores de produto

Especialistas de domínio

A interface visual de baixo código do LangFlow funciona como uma tela compartilhada, permitindo que diferentes perfis colaborem em tempo real:

Essa colaboração reduz retrabalho, acelera iterações e garante alinhamento entre áreas.

Novas Funções no Desenvolvimento com IA: A adoção de ferramentas como o LangFlow aponta para uma nova configuração organizacional, com o surgimento de duas novas funções:

Orquestrador de IA

Responsável por planejar, conectar e estruturar os diferentes blocos de uma aplicação de IA. Atua como um estrategista técnico, integrando modelos, dados e fluxos para entregar valor ao negócio.

Designer de Fluxos

Foca na experiência visual e funcional dos fluxos de IA. Usa ferramentas no-code ou low-code (como LangFlow) para construir e testar soluções, mesmo sem conhecimento avançado em programação.

Esses papéis atuam como pontes entre os requisitos de negócio e a implementação técnica, consolidando uma prática de desenvolvimento mais ágil, colaborativa e sustentável.

O Modelo de Execução: Grafos Acíclicos Direcionados (DAGs)

Os Grafos Acíclicos Direcionados (DAGs) representam o núcleo do modelo de execução adotado por diversas ferramentas de orquestração, incluindo o LangFlow. Eles permitem estruturar fluxos de trabalho de forma clara, previsível e rastreável, garantindo que cada etapa dependa de resultados anteriores e evitando ciclos infinitos. Esse formato assegura estabilidade, depuração facilitada e maior controle sobre a sequência lógica de execução, tornando-se ideal para prototipagem e automações lineares em sistemas de IA.

Carregar Dados -> Dividir -> Embutir -> Armazenar -> Recuperar -> Gerar

No entanto, a natureza “Acíclica” do modelo DAG significa que ele, por definição, não pode suportar ciclos ou laços na sua estrutura de grafo. Esta característica impõe uma limitação significativa para sistemas de agentes avançados que requerem raciocínio iterativo, laços de autocorreção ou comportamentos cíclicos e com estado. Esta escolha arquitetural contrasta com frameworks como o LangGraph, que são explicitamente projetadas para lidar com ciclos, oferecendo um paradigma de orquestração mais flexível para agentes complexos.

Arquiteturas Centrais

A arquitetura do LangFlow é construída em torno de três conceitos fundamentais que trabalham em conjunto para permitir a criação de aplicações de IA.

1. Fluxos (Flows)

2. Componentes

3. Agentes

Interoperabilidade e o MCP

É possível trabalhar com o LangFlow integrando-o ao MCP, permitindo que o fluxo interaja com múltiplos modelos e ferramentas de forma padronizada, escalável e interoperável. Isto é, o LangFlow evoluiu para ser tanto um servidor como um cliente do MCP, uma característica crítica para sistemas de IA modernos e distribuídos. Veja o Protocolos de Integração entre Modelos Computacionais para saber mais detalhes sobre este protocolo que será abordado profundamente no próximo capítulo.

As atualizações recentes (versão 1.6) dicionaram camadas de segurança como a autenticação OAuth para servidores MCP. O que sinaliza um movimento em direção a uma comunicação segura entre agentes, pronta para produção.

Por que o LangFlow opta pelos DAGs? Simplicidade e estabilidade são priorizadas em vez de flexibilidade total.

Essa abordagem está alinhada com o propósito principal do LangFlow:

prototipagem rápida e confiável de workflows lineares.

Mas... e quando precisamos de mais sofisticação? A equipe de desenvolvimento reconhece as limitações dos DAGs para a criação de agentes mais avançados. Por isso, introduziu o suporte ao MCP (Model Context Protocol).

O MCP atua como uma “saída de emergência estratégica” para contornar as limitações do DAG sem abrir mão da simplicidade do LangFlow.

Como funciona essa integração?

Resultado: arquitetura híbrida e poderosa

O suporte a MCP transforma o LangFlow de um criador visual isolado em uma peça estratégica e interoperável no desenvolvimento de sistemas de IA modernos.

Em resumo, nesta secção, estabelecemos o LangFlow como uma poderosa ferramenta de prototipagem visual, cuja arquitetura baseada em Grafos Acíclicos Dirigidos (DAGs) se destaca na aceleração do desenvolvimento de workflows lineares, como os pipelines de RAG. A sua interface intuitiva democratiza o acesso à construção de aplicações de IA e serve como uma “linguagem comum” para equipas multidisciplinares.

No entanto, também identificamos a sua limitação arquitetural inerente: a barreira da aciclicidade, que impede a criação de agentes com comportamentos iterativos e de autocorreção. A resposta estratégica do LangFlow a esta limitação não foi alterar o seu núcleo, mas sim abraçar a interoperabilidade através do Protocolo de Contexto de Modelo (MCP). O MCP funciona como uma ponte, permitindo que os fluxos lineares e fáceis de construir no LangFlow se conectem e orquestrem sistemas externos mais complexos e potencialmente cíclicos.

Com esta ponte estabelecida, o próximo passo lógico é explorar a arquitetura dos sistemas que vivem do outro lado — aqueles projetados desde o início para gerir ciclos, estado e a lógica complexa que define os agentes verdadeiramente autónomos.

LangGraph

O LangGraph é uma evolução das ideias do LangChain, mas com foco em grafos de execução.
Isso permite mapear fluxos complexos de decisão como se fossem diagramas visuais, trazendo:

Essa abordagem é indicada para sistemas críticos que exigem rastreabilidade e controle.

A Era das Cadeias Lineares

No contexto do LangChain, um DAG representa um fluxo de trabalho onde os dados se movem em uma única direção, de um passo para o próximo, sem a possibilidade de retornar a um estado anterior. Pense em uma linha de montagem: cada estação realiza uma tarefa específica e passa o produto para a próxima, mas o produto nunca volta para uma estação anterior. Esse modelo é extraordinariamente eficaz para tarefas sequenciais e previsíveis. Um exemplo clássico é um pipeline de Geração Aumentada por Recuperação (RAG - Retrieval-Augmented Generation):

  1. Entrada do Usuário: Recebe uma pergunta.

  2. Recuperação: Busca documentos relevantes em uma base de dados vetorial.

  3. Aumento: Adiciona o contexto recuperado à pergunta original.

  4. Geração: Envia o prompt aumentado para um LLM para gerar a resposta final.

Diferença dos fluxos de Langchain e Langgraph. Fonte: Adaptado de .

Figure 2:Diferença dos fluxos de Langchain e Langgraph. Fonte: Adaptado de Chopra (2025).

Este fluxo é linear, determinístico e perfeitamente modelado por um DAG. Cada passo flui para o seguinte, e o processo termina com a resposta. Para uma vasta gama de aplicações, desde chatbots de perguntas e respostas até sumarizadores de documentos, essa abordagem é suficiente e robusta.

A Barreira da Aciclicidade

Contudo, à medida que a ambição por trás das aplicações de IA cresceu, as limitações do paradigma DAG tornaram-se cada vez mais evidentes, especialmente no desenvolvimento de agentes autônomos. Agentes verdadeiramente inteligentes não operam em linhas retas; eles deliberam, corrigem seus próprios erros e adaptam suas estratégias com base em novas informações. A natureza estritamente unidirecional dos DAGs impõe barreiras fundamentais a esse tipo de comportamento dinâmico.

A Mudança de Paradigma de “Fluxo de Trabalho” para “Modelo de Estado”

A constatação de que os DAGs eram insuficientes para a próxima geração de agentes de IA levou a uma reavaliação fundamental da própria natureza da orquestração. A limitação não era apenas a ausência de ciclos, mas a falta de um conceito central e persistente de “estado” que evolui ao longo desses ciclos. Um DAG é, em essência, um pipeline de transformação de dados, análogo a um processo de ETL (Extract, Transform, Load). Os dados entram, são processados em etapas e saem.

LangGraph surge como a resposta a essa limitação, mas não é meramente um “LangChain com loops”. Ele representa uma mudança filosófica profunda. A principal abstração introduzida pelo LangGraph é o StatefulGraph, ou Grafo de Estado. Essa mudança de arquitetura reflete uma transição na forma como concebemos a orquestração de LLMs: passamos de vê-la como um processo de ETL de dados para vê-la como a simulação de um agente cognitivo com memória e capacidade de raciocínio.

Portanto, LangGraph não deve ser visto como uma simples atualização incremental do LangChain. Ele é um framework projetado para um paradigma de programação de IA inteiramente novo, focado na criação de sistemas dinâmicos, com estado e cíclicos, que podem emular processos de deliberação e auto-correção, abrindo as portas para a construção de agentes verdadeiramente autônomos e robustos.

Para construir agentes capazes de raciocínio complexo, iteração e adaptação, é necessária uma arquitetura que vá além dos fluxos lineares. LangGraph fornece exatamente isso, introduzindo um modelo computacional baseado em grafos de estado.

O Paradigma do Grafo de Estado (StatefulGraph): O Coração do Agente

No centro do LangGraph está a classe StatefulGraph. Diferente dos grafos tradicionais que simplesmente passam a saída de um nó como entrada para o próximo, um StatefulGraph opera sobre um objeto de estado centralizado e persistente. Este objeto de estado, frequentemente definido como uma TypedDict ou um BaseModel Pydantic em Python, serve como a “memória de trabalho” ou o “contexto” completo da execução do agente.

Cada nó no grafo recebe o estado atual completo como sua entrada. Ao concluir sua computação, o nó não retorna apenas um resultado isolado, mas sim um objeto que especifica como o estado central deve ser atualizado. O LangGraph então se encarrega de fundir essa atualização no estado principal.

Em suma, o StatefulGraph transforma a computação de um simples fluxo de dados para a simulação de um processo com memória, onde o estado evolui a cada passo, refletindo o progresso do agente em direção ao seu objetivo.

Anatomia de um Grafo em LangGraph: Nós e Arestas

Um grafo em LangGraph é composto por dois elementos primários: nós (nodes), que representam as unidades de computação, e arestas (edges), que definem o fluxo de controle entre esses nós.

Nós (Nodes): As Unidades de Computação

Um nó em LangGraph é definido de forma extremamente flexível: pode ser qualquer função ou objeto “chamável” (callable) em Python. Essa flexibilidade permite que um nó encapsule uma variedade de operações, desde as mais simples às mais complexas:

A única restrição é que a função do nó deve aceitar o objeto de estado como seu único argumento e retornar um dicionário (ou um objeto similar) contendo as atualizações a serem aplicadas ao estado.

Arestas (Edges): As Vias de Lógica e Controle

As arestas conectam os nós e ditam a ordem de execução. LangGraph suporta dois tipos principais de arestas, e é na combinação delas que reside o poder do framework.

É através das arestas condicionais que um agente pode decidir se deve chamar outra ferramenta, refinar sua abordagem, pedir ajuda a um humano ou finalizar o trabalho por ter alcançado uma solução satisfatória. Isso permite a implementação de ciclos, lógica de ramificação complexa e comportamento verdadeiramente dinâmico.

Construindo seu Primeiro Agente Cíclico (Tutorial com Código)

Antes de avançarmos, é hora de colocar os conceitos em prática. Vamos construir um agente de pesquisa interativo, simples na estrutura, mas poderoso no comportamento. Seu funcionamento vai além do tradicional “pergunta e resposta”: ele será capaz de consultar uma ferramenta de busca, interpretar os resultados obtidos e tomar decisões sobre os próximos passos.

Se a resposta for satisfatória, ótimo — o agente encerra o processo. Caso contrário, ele refina a pergunta, pesquisa novamente e recomeça o ciclo, até reunir informações suficientes para responder com segurança. Essa capacidade de avaliar, decidir e agir iterativamente é justamente o que caracteriza um agente cíclico, e o que torna o LangGraph uma tecnologia tão estratégica.

Mais do que um simples tutorial de código, o que veremos a seguir é uma porta de entrada para modelos de raciocínio autônomo, com aplicações reais em assistentes inteligentes, bots de atendimento, ferramentas de busca e muito mais.

Cenário: Um agente que responde a perguntas usando uma busca na web simulada.

Passo 1: Definição do Estado

Primeiro, definimos a estrutura da “memória” do nosso agente usando TypedDict. O estado irá rastrear a pergunta, as mensagens trocadas (para manter o histórico), e o número de iterações.

from typing import List, TypedDict
from langgraph.graph import StateGraph, END
import operator # Usado para acumular mensagens

# Define a estrutura do estado do nosso grafo.
# Este objeto será passado entre todos os nós.
class AgentState(TypedDict):
    question: str
    messages: Annotated[list, operator.add]
    # O Annotated e o operator.add permitem que a chave 'messages' funcione como um acumulador.
    # Novas mensagens serão adicionadas à lista existente em vez de substituí-la.
    iterations: int

Passo 2: Definição dos Nós

Agora, criamos as funções Python que servirão como os nós do nosso grafo. Cada função recebe o estado e retorna um dicionário com as atualizações.

import random

# Nó 1: A ferramenta de busca (simulada)
def search_tool(state: AgentState) -> dict:
    print("---EXECUTANDO FERRAMENTA DE BUSCA---")
    question = state['question']
    iterations = state['iterations']
    
    # Simula uma busca que pode ou não encontrar a resposta na primeira tentativa
    if "LangGraph" in question and iterations == 0:
        search_result = "Informação insuficiente sobre LangGraph. Tente refinar a busca."
    else:
        search_result = "LangGraph é uma biblioteca para construir agentes de IA com estado e ciclos."
    
    return {"messages": [search_result], "iterations": iterations + 1}

# Nó 2: O LLM que analisa os resultados e gera a resposta final
def generate_answer(state: AgentState) -> dict:
    print("---GERANDO RESPOSTA FINAL---")
    last_message = state['messages'][-1]
    if "insuficiente" in last_message:
        # Se a busca falhou, o agente decide refinar a pergunta
        print(">> Decisão: Refinar a busca.")
        refined_question = state['question'] + " (detalhado)"
        action_message = "Refinando a busca para obter mais detalhes."
        return {"question": refined_question, "messages": [action_message]}
    else:
        # Se a busca foi bem-sucedida, gera a resposta final
        print(">> Decisão: Gerar resposta final.")
        final_answer = f"Resposta final encontrada: {last_message}"
        return {"messages": [final_answer]}

Passo 3: Definição da Lógica Cíclica (Nó de Roteamento)

Este é o cérebro do nosso agente. A função should_continue inspeciona o estado e decide para onde o fluxo deve ir em seguida: de volta para a busca ou para o final.

def should_continue(state: AgentState) -> str:
    print("---VERIFICANDO CONDIÇÃO DE CONTINUAÇÃO---")
    last_message = state['messages'][-1]
    # Se a última mensagem indica que a busca precisa ser refinada, continuamos o ciclo
    if "Refinando a busca" in last_message:
        return "continue"
    # Se atingimos um limite de iterações ou encontramos a resposta, terminamos
    elif state['iterations'] >= 3:
        return "end"
    else:
        return "end"

Passo 4: Construção e Compilação do Grafo

Finalmente, montamos o grafo, adicionando os nós e as arestas (incluindo a aresta condicional).

# Instancia o grafo, associando-o à nossa definição de estado
workflow = StateGraph(AgentState)

# Adiciona os nós ao grafo
workflow.add_node("search", search_tool)
workflow.add_node("analyze", generate_and_analyze)

# Define o ponto de entrada do grafo
workflow.set_entry_point("search")

# Adiciona as arestas
# Após a busca, sempre vamos para a geração/análise
workflow.add_edge("search", "analyze")

# Adiciona a aresta condicional: o "cérebro" do agente
workflow.add_conditional_edges(
    "analyze",  # Nó de origem
    should_continue,  # Função de roteamento
    {
        "continue": "search",  # Se a função retornar "continue", volta para a busca (CICLO)
        "end": END  # Se a função retornar "end", termina a execução
    }
)

# Compila o grafo em um objeto executável
app = workflow.compile()

Passo 5: Execução do Grafo

Agora podemos executar nosso agente. Observe como ele executa o ciclo uma vez antes de encontrar a resposta.

# Executa o grafo com uma entrada inicial
initial_input = {"question": "O que é LangGraph?", "messages": [], "iterations": 0}
for event in app.stream(initial_input, {"recursion_limit": 5}):
    for key, value in event.items():
        print(f"\nNó: {key}")
        print(f"Estado atualizado: {value}")

# Saída Esperada:
#Nó: search
#Estado atualizado: {'messages': ['Informação insuficiente sobre LangGraph. Tente refinar a busca.'], 'iterations': 1}
#---ANALISANDO RESULTADO DA BUSCA---
#>> Decisão: Refinar a busca.
#Nó: analyze
#Estado atualizado: {'question': 'O que é LangGraph? (detalhado)', 'messages': ['Informação insuficiente sobre LangGraph. Tente refinar a busca.', 'Refinando a busca para obter mais detalhes.']}
#---VERIFICANDO CONDIÇÃO DE CONTINUAÇÃO---
#---EXECUTANDO FERRAMENTA DE BUSCA---
#Nó: search
#Estado atualizado: {'messages': ['Informação insuficiente sobre LangGraph. Tente refinar a busca.', 'Refinando a busca para obter mais detalhes.', 'LangGraph é uma biblioteca para construir agentes de IA com estado e ciclos, permitindo a criação de aplicações LLM confiáveis e robustas.'], 'iterations': 2}
#---ANALISANDO RESULTADO DA BUSCA---
#>> Decisão: Gerar resposta final.
#Nó: analyze
#Estado atualizado: {'messages': ['Informação insuficiente sobre LangGraph. Tente refinar a busca.', 'Refinando a busca para obter mais detalhes.', 'LangGraph é uma biblioteca para construir agentes de IA com estado e ciclos, permitindo a criação de aplicações LLM confiáveis e robustas.', 'Resposta final encontrada: LangGraph é uma biblioteca para construir agentes de IA com estado e ciclos, permitindo a criação de aplicações LLM confiáveis e robustas.']}
#---VERIFICANDO CONDIÇÃO DE CONTINUAÇÃO---
#Nó: __end__
#Estado atualizado: {'question': 'O que é LangGraph? (detalhado)', 'messages': ['Informação insuficiente sobre LangGraph. Tente refinar a busca.', 'Refinando a busca para obter mais detalhes.', 'LangGraph é uma biblioteca para construir agentes de IA com estado e ciclos, permitindo a criação de aplicações LLM confiáveis e robustas.', 'Resposta final encontrada: LangGraph é uma biblioteca para construir agentes de IA com estado e ciclos, permitindo a criação de aplicações LLM confiáveis e robustas.'], 'iterations': 2}

Este exemplo simples demonstra o poder do paradigma do LangGraph. A capacidade de criar ciclos controlados por lógica condicional é o que permite a construção de agentes que podem raciocinar, planejar e se auto-corrigir.

Padrões Avançados: Multi-Agentes e Intervenção Humana

À medida que os desafios do mundo real se tornam mais complexos, também evoluem os requisitos das aplicações baseadas em IA. A arquitetura do LangGraph não se limita à construção de agentes simples: ela se expande com naturalidade para comportar padrões avançados, como sistemas com múltiplos agentes cooperando entre si e fluxos de trabalho que integram decisões humanas no processo automatizado. A seguir, exploraos padrões Colaboração Multi-Agente e Intervenção Humana no Loop (HITL).

Colaboração Multi-Agente

Sistemas complexos raramente são resolvidos por um único agente monolítico. Uma abordagem mais robusta é criar um sistema de múltiplos agentes, cada um com sua especialidade. LangGraph é ideal para orquestrar essa colaboração.

Essa abordagem modular torna o sistema mais fácil de desenvolver, testar e manter.

Intervenção Humana no Loop (HITL)

Para aplicações de missão crítica, a autonomia total de um agente pode representar um risco significativo. O LangGraph oferece uma solução nativa e elegante para incorporar Intervenção Humana no Loop (HITL), permitindo equilibrar automação e supervisão humana de forma segura e auditável.

Como funciona na prática

Após a intervenção humana, o estado do grafo é atualizado com a orientação fornecida, e a execução é retomada do ponto exato em que parou.


Por que isso importa? A capacidade de integrar a supervisão humana transforma o LangGraph de uma ferramenta para agentes autônomos em uma plataforma para construir sistemas de IA colaborativos, auditáveis e seguros.

Em resumo, o LangGraph possibilita construir agentes inteligentes e responsáveis, que unem a velocidade da automação à sabedoria da intervenção humana — um passo decisivo rumo à IA verdadeiramente confiável.

Sintetizando o que foi visto nesta seção sobre LangGraph, vimos que a jornada através da arquitetura do LangGraph revela uma evolução fundamental na orquestração de LLMs. As limitações inerentes aos Grafos Acíclicos Dirigidos (DAGs) para a construção de agentes inteligentes — notavelmente a sua incapacidade de iterar e auto-corrigir — necessitaram de uma mudança de paradigma. O LangGraph aborda este desafio ao introduzir o StatefulGraph, transformando o modelo de desenvolvimento de um pipeline de dados linear para a simulação de um processo cognitivo com memória. Através da implementação de nós, arestas condicionais e um objeto de estado persistente, torna-se possível construir agentes capazes de raciocínio cíclico, deliberação e adaptação dinâmica.

As implicações desta arquitetura estendem-se muito para além da mera capacidade funcional. A capacidade de orquestrar sistemas multi-agente, onde agentes especializados colaboram sob a direção de um supervisor, permite a decomposição modular de problemas complexos.

No entanto, a integração nativa de padrões de Intervenção Humana no Loop (HITL) é talvez a característica mais crítica para a adoção empresarial. Ela fornece um mecanismo crucial para o controlo e a segurança, permitindo a supervisão humana antes da execução de ações de alto impacto. Isto transforma o LangGraph de um framework para construir agentes autónomos numa plataforma para a engenharia de sistemas de inteligência confiáveis, auditáveis e seguros.

Com o núcleo lógico do agente agora definido, o foco deve deslocar-se da orquestração para a implementação e implementação. Como é que um agente com estado e potencialmente de longa duração é alojado? Que padrões arquitetónicos — Monolítico, Microsserviços, Serverless — são mais adequados para gerir estas novas cargas de trabalho? Como é que estes sistemas são monitorizados, escalados e mantidos num ambiente de produção? Estas questões de arquitetura de sistemas e MLOps representam a próxima fronteira na transformação de um agente poderoso num serviço robusto de nível empresarial.

Gradio

O Gradio é uma biblioteca de código aberto em Python que simplifica a criação de interfaces de usuário (UI) para modelos de machine learning, APIs e funções Python arbitrárias. É bastante utilizado para demonstrações públicas e testes de usabilidade, além de ser integrado ao ecossistema Hugging Face Gradio (2021).

mapear funções de entrada (input) e saída (output) para componentes interativos.

Parte 1: Primeiros Passos

Nesta seção, vamos configurar o ambiente e criar nossa primeira interface com Gradio.

1. Configuração do Ambiente

  1. Crie uma pasta para o seu projeto e, dentro dela, abra o terminal.

  2. Crie o ambiente virtual:

python -m venv venv

  1. Ative o ambiente virtual:

2. Instalação do Gradio

Com o ambiente virtual ativado, instale o Gradio usando o pip:

pip install gradio

A instalação inclui todas as dependências necessárias para começar a criar suas interfaces.

3. Primeira Aplicação: Uma Função Simples

  1. Crie um arquivo Python, por exemplo, app_gradio.py.

  2. Defina uma função Python e use o Gradio para criar uma interface para ela.

Exemplo de Código

O código abaixo representa um aplicativo simples para entender a funcionalidade do Gradio.

app_gradio.py

import gradio as gr

# 1. Defina a função que seu app irá executar
def saudar(nome):
    return f"Olá, {nome}! Bem-vindo ao Gradio."

# 2. Crie a interface Gradio
#    - fn: a função a ser chamada
#    - inputs: o tipo de componente para a entrada (texto, imagem, etc.)
#    - outputs: o tipo de componente para a saída
iface = gr.Interface(fn=saudar, inputs="text", outputs="text")

# 3. Inicie a aplicação
iface.launch()

4. Executando a Aplicação

No terminal, com o ambiente virtual ativado, execute o comando:

python app_gradio.py

O Gradio iniciará um servidor local e imprimirá um endereço no console (geralmente http://127.0.0.1:7860). Abra este link no seu navegador para ver e interagir com sua aplicação. Uma das funcionalidades mais poderosas é que, ao usar iface.launch(share=True), o Gradio gera um link público temporário, permitindo que você compartilhe sua demo com qualquer pessoa no mundo por 72 horas.

Parte 2: Adicionando Interatividade com Componentes

O Gradio destaca-se pela variedade de componentes de entrada e saída que oferece, prontos para uso em tarefas de IA.

1. Componentes de Entrada (Inputs)

Os inputs definem como o usuário fornecerá dados para a sua função.

Exemplo de Código com Múltiplos Inputs

import gradio as gr

def gerar_historia(personagem, lugar, idade):
    return f"Era uma vez, em {lugar}, vivia um(a) {personagem} de {idade} anos. A aventura estava prestes a começar..."

iface = gr.Interface(
    fn=gerar_historia,
    inputs=[
        gr.Textbox(label="Nome do Personagem"),
        gr.Dropdown(["uma floresta mágica", "uma cidade futurista", "um castelo antigo"], label="Onde a história se passa?"),
        gr.Slider(minimum=10, maximum=100, step=1, label="Idade do Personagem")
    ],
    outputs="text",
    title="Gerador de Histórias com IA"
)

iface.launch()

2. Componentes de Saída (Outputs)

Os outputs definem como o resultado da sua função será exibido.

Exemplo de Código com Output de Imagem (Conceitual)

import gradio as gr
import numpy as np

# Função fictícia que gera uma imagem (um gradiente)
def gerar_imagem_gradiente(cor1, cor2):
    # Lógica para criar uma imagem (array NumPy)
    # Neste exemplo, criamos uma imagem preta simples
    imagem_array = np.zeros((100, 200, 3), dtype=np.uint8) 
    # O comentário abaixo deixa claro que a lógica de geração da imagem foi omitida
    # ... aqui iria o código para gerar o gradiente real ...
    print("Gerando imagem conceitual...") # Opcional: um print no console é útil para debug
    return imagem_array

iface = gr.Interface(
    fn=gerar_imagem_gradiente,
    inputs=["text", "text"],
    outputs=gr.Image(label="Resultado do Gradiente"),
    title="Gerador de Imagens"
)

iface.launch()

Parte 3: Aplicações Robustas

Para criar demos mais complexas e organizadas, você pode usar blocos e gerenciar o estado.

1. Organizando o Layout com Blocos (gr.Blocks)

Para ter controle total sobre onde os componentes aparecem, use gr.Blocks. Isso permite criar layouts com linhas, colunas e abas, oferecendo muito mais flexibilidade do que gr.Interface.

Exemplo de Código:

import gradio as gr

def saudacao_completa(nome, saudacao):
    return f"{saudacao}, {nome}!"

with gr.Blocks() as demo:
    gr.Markdown("# App de Saudações Personalizadas")
    
    with gr.Row():
        # Coluna 1: Entradas
        with gr.Column(scale=1):
            input_nome = gr.Textbox(label="Seu Nome")
            input_saudacao = gr.Dropdown(["Olá", "Bom dia", "Boa noite"], label="Escolha a Saudação")
            btn = gr.Button("Gerar Saudação")
    
        # Coluna 2: Saída
        with gr.Column(scale=2):
            output_texto = gr.Textbox(label="Resultado")

    # Define a interatividade: quando o botão for clicado, chame a função
    btn.click(fn=saudacao_completa, inputs=[input_nome, input_saudacao], outputs=output_texto)

demo.launch()

2. Gerenciando o Estado (gr.State)

Em aplicações interativas, como um chatbot, você precisa manter o histórico da conversa. O Gradio usa o componente gr.State para passar dados entre as execuções de uma função sem exibi-los na UI.

Exemplo de Código: Chatbot Simples

import gradio as gr
import random

def chatbot_resposta(mensagem, historico):
    # Adiciona a mensagem do usuário ao histórico
    historico.append((mensagem, ""))
    
    # Simula uma resposta do bot
    respostas_bot = ["Que interessante!", "Conte-me mais.", "Entendo."]
    resposta_bot = random.choice(respostas_bot)
    
    # Adiciona a resposta do bot ao histórico
    historico[-1] = (mensagem, resposta_bot)
    
    return historico, "" # Retorna o histórico atualizado e limpa a caixa de texto

with gr.Blocks() as demo:
    gr.Markdown("## Chatbot Simples")
    
    # Componente de estado para armazenar o histórico (invisível na UI)
    historico_estado = gr.State([])
    
    chatbot = gr.Chatbot()
    caixa_texto = gr.Textbox(placeholder="Digite sua mensagem aqui...")
    
    # A função `chatbot_resposta` recebe a mensagem e o estado do histórico
    caixa_texto.submit(
        fn=chatbot_resposta,
        inputs=[caixa_texto, historico_estado],
        outputs=[chatbot, caixa_texto] # Atualiza o chatbot e limpa a caixa de texto
    )

demo.launch()

Parte 4: Compartilhando sua Aplicação (Deploy)

A beleza do Gradio está na facilidade de compartilhamento.

1. Compartilhamento Rápido (share=True):

Como mencionado, a forma mais simples de compartilhar é adicionando o parâmetro share=True ao método launch():Python

iface.launch(share=True)

2. Hospedagem Permanente com Hugging Face Spaces

Para uma solução gratuita e permanente, a plataforma Hugging Face Spaces é a melhor opção. Ela é totalmente integrada ao Gradio.

Informações Adicionais e Boas Práticas

References
  1. LangChain. (2022). LangChain: Building applications with LLMs. https://www.langchain.com
  2. LangFlow. (2023). LangFlow Documentation. https://github.com/logspace-ai/langflow
  3. Chopra, R. (2025). LangChain vs LangGraph — The AI Framework Battle That’s Dividing Developers. https://ritik-chopra28.medium.com/langchain-vs-langgraph-the-ai-framework-battle-thats-dividing-developers-81d0fe53503b
  4. Gradio. (2021). Gradio: Build Machine Learning Web Apps. https://gradio.app