Guia dos Deep Agents do LangChain: recursos, ferramentas e configuração

Construa agentes de IA mais capazes com os Deep Agents do LangChain. Saiba como o planejamento, a chamada de ferramentas, o gerenciamento de sistema de arquivos e os fluxos de trabalho com subagentes permitem a execução autônoma de tarefas e, em seguida, conecte a API da Kimi para potencializar seus agentes com recursos avançados de compreensão de linguagem e raciocínio.

Obtenha sua chave de API da Kimi

Tempo de leitura: 12 minutos2026-08-14

Conecte a API da Kimi aos Deep Agents do LangChain

Os agentes de IA estão se tornando mais úteis à medida que deixam de apenas responder perguntas e passam a lidar com tarefas do início ao fim. Os Deep Agents do LangChain adicionam mais controle e flexibilidade ao ajudar os agentes a dividir o trabalho, usar diferentes ferramentas, gerenciar informações e coordenar tarefas menores. Isso facilita a criação de agentes capazes de lidar com fluxos de trabalho do mundo real sem precisar de orientação constante. Vamos explorar como os Deep Agents do LangChain funcionam e o que você pode construir com eles.

O que são os Deep Agents do LangChain?

Os Deep Agents do LangChain são uma estrutura de agentes construída sobre os blocos de construção principais do LangChain e o runtime do LangGraph. Eles ampliam os fluxos de trabalho de agentes padrão com recursos integrados, como acesso ao sistema de arquivos, delegação a subagentes, planejamento, memória e suporte à intervenção humana. Os Deep Agents usam um loop de agente que combina raciocínio, chamada de ferramentas e execução iterativa, tornando-os adequados para tarefas complexas que exigem várias etapas, grandes quantidades de contexto e fluxos de trabalho coordenados.

Diferentemente dos agentes básicos, que basicamente chamam ferramentas em um loop simples, os Deep Agents oferecem infraestrutura adicional para lidar com tarefas de longa duração. Eles podem gerenciar arquivos, delegar trabalho a subagentes especializados, manter contexto em fluxos de trabalho complexos e permitir intervenção humana quando necessário. Esses recursos integrados reduzem a quantidade de engenharia personalizada necessária ao construir sistemas de agentes avançados.

Como funcionam os Deep Agents do LangChain

Quando um Deep Agent recebe uma tarefa, ele analisa a solicitação e planeja as etapas necessárias para concluí-la. Em seguida, utiliza as ferramentas disponíveis, como busca, execução de código ou operações no sistema de arquivos, para coletar informações e realizar ações.

Durante a execução, os Deep Agents gerenciam o contexto lendo e escrevendo arquivos. Em vez de manter todos os resultados intermediários dentro do histórico da conversa, eles podem armazenar grandes quantidades de informação externamente e recuperá-las quando necessário. Essa abordagem ajuda os agentes a lidar com fluxos de trabalho mais longos, reduzindo as limitações causadas pelo tamanho da janela de contexto.

Para tarefas complexas que envolvem múltiplas áreas de trabalho, os Deep Agents podem delegar subtarefas específicas a subagentes especializados. Cada subagente se concentra em um objetivo definido e retorna os resultados relevantes ao agente principal. O agente principal então combina as saídas dos subagentes, as informações recuperadas e os arquivos armazenados para gerar uma resposta completa e coerente.

Com recursos como planejamento, uso de ferramentas, gerenciamento de sistema de arquivos, colaboração entre subagentes e supervisão humana, os Deep Agents do LangChain fornecem uma base para a construção de sistemas de IA mais capazes, aptos a lidar com tarefas reais de múltiplas etapas.

Capacidades principais dos Deep Agents: planejamento, ferramentas e execução

Os Deep Agents conseguem lidar com tarefas que exigem várias etapas, decisões e ações. Seus recursos principais os ajudam a planejar o trabalho, usar as ferramentas certas e concluir cada etapa com eficiência e menos intervenção manual. Vamos analisar essas capacidades em detalhes:

Planejamento de tarefas

O planejamento de tarefas permite que os agentes criem e gerenciem uma lista de tarefas estruturada durante a execução. Em vez de tratar um objetivo complexo como uma única instrução, os agentes podem dividi-lo em etapas menores, acompanhar o progresso e atualizar o status das tarefas ao longo do fluxo de trabalho.

Quando usar o planejamento

Tarefas longas ou complicadas com várias etapas
Tarefas que se beneficiam de acompanhamento explícito de progresso e execução estruturada
Interfaces que transmitem o progresso a partir do estado do agente

Como habilitá-lo

Passe TodoListMiddleware para o parâmetro middleware. Isso fornece ao agente uma ferramenta write_todos para manter uma lista de tarefas estruturada com controle de status (pending, in_progress, completed).

from deepagents import create_deep_agent
from deepagents.middleware import TodoListMiddleware

agent = create_deep_agent(
    model="your-model",
    middleware=[TodoListMiddleware()],
)

As tarefas são mantidas no estado do agente, oferecendo aos agentes uma camada leve de planejamento para organizar trabalhos de longa duração.

Ferramentas de sistema de arquivos virtual

Os Deep Agents oferecem um sistema de arquivos virtual configurável, suportado por backends conectáveis: estado em memória, disco local, armazenamento do LangGraph, roteamento composto ou backends personalizados com regras de permissão.

Ferramentas de sistema de arquivos integradas

Ferramenta	Descrição
`ls`	Lista arquivos em um diretório com metadados (tamanho, data de modificação)
`read_file`	Lê o conteúdo de arquivos com numeração de linhas; suporta offset/limit para arquivos grandes; também retorna blocos de conteúdo multimodal para imagens, vídeos, áudios e documentos
`write_file`	Cria um novo arquivo ou sobrescreve um existente
`edit_file`	Realiza substituições exatas de strings em arquivos (com modo de substituição global)
`delete`	Exclui um arquivo ou diretório recursivamente
`glob`	Encontra arquivos que correspondem a padrões (ex.: `*/.py`)
`grep`	Pesquisa o conteúdo de arquivos com múltiplos modos de saída
`execute`	Executa comandos de shell no ambiente (apenas backends sandbox)

Extensões multimodais suportadas

Imagem: .png, .jpg, .jpeg, .gif, .webp, .heic, .heif
Vídeo: .mp4, .mpeg, .mov, .avi, .flv, .mpg, .webm, .wmv, .3gpp
Áudio: .wav, .mp3, .aiff, .aac, .ogg, .flac
Documento: .pdf, .ppt, .pptx

Permissões do sistema de arquivos

O harness suporta regras declarativas de permissão que controlam quais arquivos e diretórios o agent pode ler ou escrever. As regras são avaliadas de cima para baixo, com a semântica de primeira correspondência prevalece.

from deepagents import create_deep_agent

agent = create_deep_agent(
    model="anthropic:your-model",
    permissions=[
        {"operations": ["read", "write"], "paths": ["/workspace/**"], "mode": "allow"},
        {"operations": ["read"], "paths": [".env", "**/secrets/**"], "mode": "deny"},
    ],
)

from deepagents import create_deep_agent

agent = create_deep_agent(
    model="anthropic:your-model",
    permissions=[
        {"operations": ["read", "write"], "paths": ["/workspace/**"], "mode": "allow"},
        {"operations": ["read"], "paths": [".env", "**/secrets/**"], "mode": "deny"},
    ],
)

Isso permite restringir agents a diretórios específicos, proteger arquivos sensíveis e conceder aos subagents um acesso mais restrito do que o agent principal.

Restringindo o acesso a ferramentas

Você pode expor apenas um subconjunto das ferramentas do sistema de arquivos passando uma lista de permissões tools para FilesystemMiddleware. read_file deve sempre estar incluída.

from deepagents import create_deep_agent
from deepagents.middleware import FilesystemMiddleware

# Read-only agent
agent = create_deep_agent(
    model="your-model",
    middleware=[
        FilesystemMiddleware(backend=backend, tools=["read_file", "ls", "glob", "grep"]),
    ],
)

from deepagents import create_deep_agent
from deepagents.middleware import FilesystemMiddleware

# Read-only agent
agent = create_deep_agent(
    model="your-model",
    middleware=[
        FilesystemMiddleware(backend=backend, tools=["read_file", "ls", "glob", "grep"]),
    ],
)

Subagents (Delegação)

O harness inclui uma ferramenta task integrada que permite ao agent principal criar subagents efêmeros para tarefas isoladas, de longa duração, com múltiplas etapas ou paralelas.

Principais características

Contexto novo: Cada invocação cria uma nova instância de agent com seu próprio contexto
Execução autônoma: O subagent é executado de forma independente até a conclusão
Entrega única: Ele retorna um relatório final ao agent principal
Estratégia configurável: Use o subagent padrão general-purpose ou defina subagents personalizados
Eficiência de contexto: O trabalho intenso das subtarefas fica isolado e é compactado em um resultado conciso

Desativando subagents

Para executar um agent sem a ferramenta task, desative o subagent adicionado automaticamente por meio do perfil do harness e não passe subagents síncronos via subagents=. Não tente remover o SubAgentMiddleware via excluded_middleware — isso é intencionalmente rejeitado.

Capacidades de chamada de ferramentas

Os Deep Agents suportam três categorias de ferramentas:

Funções personalizadas e ferramentas LangChain

Passe funções personalizadas ou ferramentas LangChain diretamente por meio do parâmetro tools=:

from deepagents import create_deep_agent def get_weather(city: str) -> str: """Get weather for a given city.""" return f"It's always sunny in {city}!" agent = create_deep_agent( model="your-model", tools=[get_weather], system_prompt="You are a helpful assistant", )

MCP (Model Context Protocol)

Os Deep Agents suportam totalmente o MCP, permitindo conectar-se a bancos de dados, APIs, sistemas de arquivos e muito mais por meio de uma interface padrão.

Execução de código

Backends de sandbox: exponha uma ferramenta execute para comandos de shell em um ambiente isolado
Interpretadores: adicione uma ferramenta eval que executa JavaScript em um runtime QuickJS isolado para camadas programáveis leves

Conforme esses recursos se combinam, o modelo de linguagem que alimenta o agente se torna uma parte importante da configuração geral. Um modelo capaz pode ajudar os Deep Agents a entender instruções, raciocinar sobre tarefas e usar melhor as ferramentas disponíveis. A Kimi API pode fornecer essa camada de modelo, tornando-se um próximo passo natural para criar fluxos de trabalho de Deep Agent mais capazes.

Conecte a Kimi API aos Deep Agents do LangChain em 6 passos

Um modelo capaz dá ao seu Deep Agent a compreensão de linguagem e o raciocínio necessários para lidar com tarefas de forma eficaz. A Kimi API pode fornecer esses recursos enquanto o agente trabalha com ferramentas, gerencia tarefas e lida com instruções complexas. Com a camada de modelo definida, a configuração pode avançar naturalmente para a conexão da Kimi API com os LangChain Agents. Veja como conectar a Kimi API aos LangChain Deep Agents:

Passo 1: Obtenha sua chave da Kimi API

Entre na plataforma Kimi API e crie uma nova chave de API. Copie e salve a chave com segurança, pois você precisará adicioná-la à configuração dos seus Deep Agents. Essa chave de API autentica suas solicitações e permite que os Deep Agents do LangChain acessem os modelos Kimi por meio da API.

Obtenha sua chave de API da Kimi

Passo 2: Defina as variáveis de ambiente

Defina sua chave da Kimi API como uma variável de ambiente. A Kimi API usa o endpoint da API da Moonshot, então configure a seguinte variável:

export MOONSHOT_API_KEY="your-api-key-here"

export MOONSHOT_API_KEY="your-api-key-here"

A URL base da API é:

https://api.moonshot.ai/v1

https://api.moonshot.ai/v1

Passo 3: Instale as dependências

Instale os Deep Agents e as dependências necessárias do LangChain:

pip install deepagents langchain-openai
``````bash
pip install deepagents langchain-openai

Como a Kimi API é compatível com o formato da OpenAI, o langchain-openai permite que o LangChain se conecte aos modelos Kimi por meio da interface compatível com a OpenAI.

Se quiser adicionar recursos de busca na web ao seu Deep Agent, você pode opcionalmente instalar o Tavily:

pip install tavily-python

pip install tavily-python

Depois de criar uma chave de API da Tavily na plataforma Tavily, defina-a como uma variável de ambiente:

export TAVILY_API_KEY="your-tavily-api-key"

export TAVILY_API_KEY="your-tavily-api-key"

Você só precisa do Tavily se planeja adicionar ferramentas de busca na web ao seu agente.

Passo 4: Configure um Deep Agent com a Kimi API

Como a Kimi API é compatível com o formato da API da OpenAI, você pode conectá-la aos LangChain Deep Agents por meio do init_chat_model.

O exemplo a seguir cria um Deep Agent básico alimentado pelo Kimi. Você pode opcionalmente estendê-lo com ferramentas como busca na web.

Deep Agent básico alimentado pelo Kimi

from os import environ from deepagents import create_deep_agent from langchain.chat_models import init_chat_model kimi_model = init_chat_model( "kimi-k3", api_key=environ["MOONSHOT_API_KEY"], base_url="https://api.moonshot.ai/v1", temperature=0.7, ) agent = create_deep_agent( model=kimi_model, system_prompt="""You are an expert assistant. Your job is to solve tasks with structured reasoning and provide clear outputs. """, )

Adicionar recursos de busca na web (opcional)

Para ativar a busca na web, conecte uma ferramenta de busca como o Tavily:

from tavily import TavilyClient tavily_client = TavilyClient( api_key=os.environ["TAVILY_API_KEY"] ) def internet_search(query: str, max_results: int = 5): """Run a web search""" return tavily_client.search( query=query, max_results=max_results ) agent = create_deep_agent( model=kimi_model, tools=[internet_search], system_prompt="""You are an expert researcher. Use the internet search tool when additional information is required. """, )

Com essa configuração, os Deep Agents podem usar o Kimi como modelo de raciocínio enquanto acessam recursos de busca externos por meio do Tavily.

Passo 5: Execute seu Deep Agent alimentado pelo Kimi

Depois que seu Deep Agent estiver configurado com o Kimi, execute o agente para testar como ele lida com tarefas e chamadas de ferramentas.

result = agent.invoke(
    {"messages": [{"role": "user", "content": "What is LangGraph?"}]}
)

print(result["messages"][-1].content)

result = agent.invoke(
    {"messages": [{"role": "user", "content": "What is LangGraph?"}]}
)

print(result["messages"][-1].content)

Passo 6: Ative o rastreamento do LangSmith (opcional)

O rastreamento do LangSmith ajuda a monitorar a execução do agente, incluindo chamadas de ferramentas, etapas intermediárias e respostas do modelo.

Ative o rastreamento com as seguintes variáveis de ambiente:

export LANGSMITH_TRACING=true
export LANGSMITH_API_KEY="your-langsmith-api-key"

export LANGSMITH_TRACING=true
export LANGSMITH_API_KEY="your-langsmith-api-key"

Use o LangSmith quando precisar de mais visibilidade sobre os fluxos de trabalho do agente, depuração ou análise de desempenho.

Conecte agentes com a API da Kimi

Benefícios de usar a Kimi API

Conectar a Kimi API aos Deep Agents pode tornar fluxos de trabalho complexos mais capazes e mais fáceis de gerenciar. Essa combinação dá aos agentes um raciocínio mais forte, permitindo que usem ferramentas, lidem com arquivos e trabalhem em várias tarefas. Vamos analisar os principais benefícios que essa configuração pode oferecer:

Melhore o raciocínio e a execução de tarefas do agente

Os modelos Kimi oferecem forte compreensão de linguagem e capacidade de raciocínio, ajudando os Deep Agents a analisar instruções complexas, dividir tarefas e gerar respostas mais precisas. Isso permite que os agentes lidem com fluxos de trabalho de várias etapas de forma mais eficaz, com menos orientação manual.

Crie fluxos de trabalho de IA mais capazes

Com a Kimi API conectada aos Deep Agents, os desenvolvedores podem combinar os recursos do modelo Kimi com ferramentas, sistemas de arquivos e integrações externas suportadas pelo LangChain. Isso permite que os agentes realizem tarefas como pesquisa, processamento de documentos, análise de código e manipulação de dados em um fluxo de trabalho unificado.

Escale tarefas complexas com agentes autônomos

Os Deep Agents alimentados pelo Kimi podem gerenciar tarefas de longa duração criando planos, usando ferramentas e delegando subtarefas quando necessário. Isso facilita a criação de aplicações de IA capazes de concluir fluxos de trabalho complexos, reduzindo operações manuais repetitivas.

Conclusão

Construir agentes de IA confiáveis começa com a escolha da base certa para fluxos de trabalho complexos. Os LangChain Deep Agents oferecem as ferramentas e a estrutura necessárias para criar agentes capazes de planejar, usar ferramentas, gerenciar contexto e lidar com tarefas de múltiplas etapas com menos esforço manual. Com o modelo e a configuração certos, desenvolvedores podem transformar ideias avançadas de agentes em aplicações práticas. Ao integrar a Kimi API, você pode aprimorar ainda mais seus fluxos de trabalho com Deep Agents usando capacidades sólidas de raciocínio e contexto longo. Comece a explorar a Kimi API e descubra o que você pode construir com agentes de IA.

Obtenha sua chave de API da Kimi

Perguntas frequentes

Qual é a diferença entre os agentes do LangChain e os Deep Agents?

Os agentes do LangChain fornecem a base para a construção de agentes de IA que utilizam ferramentas. Os Deep Agents constroem sobre essa base com recursos adicionais, como planejamento, gerenciamento de arquivos, delegação a subagentes e tratamento de contexto. Esses recursos tornam os Deep Agents mais adequados para tarefas mais longas e complexas. Eles também reduzem a necessidade de construir esses recursos separadamente.

Para que os Deep Agents do LangChain podem ser usados?

Os Deep Agents do LangChain conseguem lidar com tarefas que exigem várias etapas, uso de ferramentas e tomada de decisão contínua. Eles podem suportar casos de uso como automação de pesquisa, análise de documentos, compreensão de código, processamento de dados e execução de fluxos de trabalho complexos. Para tarefas que envolvem múltiplas áreas de especialização, os Deep Agents podem delegar subtarefas específicas a subagentes especializados e combinar seus resultados. Ao conectar os Deep Agents à API da Kimi, os desenvolvedores podem construir aplicações de IA que aproveitam as capacidades de raciocínio da Kimi e sua ampla janela de contexto para tarefas como analisar documentos extensos, processar informações complexas e automatizar fluxos de trabalho intensivos em conhecimento.

Posso adicionar memória a um Deep Agent do LangChain?

Sim, os Deep Agents do LangChain podem suportar memória por meio de integrações de persistência e memória disponíveis. Isso ajuda os agentes a manter informações relevantes entre interações e tarefas, em vez de começar do zero a cada vez. A memória pode ser útil para fluxos de trabalho personalizados, tarefas de longa duração e informações persistentes.