Guida a LangChain Deep Agents: funzionalità, strumenti e configurazione

Crea agenti AI più capaci con LangChain Deep Agents. Scopri come pianificazione, chiamata di strumenti, gestione del filesystem e flussi di lavoro con subagent consentono l'esecuzione autonoma dei task, quindi collega Kimi API per potenziare i tuoi agenti con capacità avanzate di comprensione del linguaggio e ragionamento.

Ottieni la tua Kimi API Key

12 min di lettura2026-08-14

Collegare Kimi API a LangChain Deep Agents

Gli agenti AI stanno diventando sempre più utili man mano che vanno oltre la semplice risposta alle domande e iniziano a gestire i task dall'inizio alla fine. I LangChain Deep Agents aggiungono più controllo e flessibilità aiutando gli agenti a suddividere il lavoro, usare strumenti diversi, gestire le informazioni e coordinare task più piccoli. Questo rende più facile creare agenti in grado di gestire flussi di lavoro reali senza bisogno di una guida costante. Vediamo come funzionano i LangChain Deep Agents e cosa si può costruire con essi.

Cosa sono i LangChain Deep Agents?

I LangChain Deep Agents sono un framework per agenti costruito sui blocchi di base di LangChain e sul runtime LangGraph. Estendono i flussi di lavoro standard degli agenti con capacità integrate come l'accesso al filesystem, la delega ai subagent, la pianificazione, la memoria e il supporto human-in-the-loop. I Deep Agents utilizzano un ciclo dell'agente che combina ragionamento, chiamata di strumenti ed esecuzione iterativa, rendendoli adatti a task complessi che richiedono più passaggi, grandi quantità di contesto e flussi di lavoro coordinati.

A differenza degli agenti di base, che si limitano principalmente a chiamare strumenti in un semplice ciclo, i Deep Agents offrono un'infrastruttura aggiuntiva per gestire task di lunga durata. Possono gestire file, delegare lavoro a subagent specializzati, mantenere il contesto attraverso flussi di lavoro complessi e consentire l'intervento umano quando necessario. Queste capacità integrate riducono la quantità di sviluppo personalizzato necessaria per costruire sistemi di agenti avanzati.

Come funzionano i LangChain Deep Agents

Quando un Deep Agent riceve un task, analizza la richiesta e pianifica i passaggi necessari per completarla. Utilizza poi gli strumenti disponibili, come la ricerca, l'esecuzione di codice o le operazioni sul filesystem, per raccogliere informazioni e compiere azioni.

Durante l'esecuzione, i Deep Agents gestiscono il contesto leggendo e scrivendo file. Invece di conservare tutti i risultati intermedi all'interno della cronologia della conversazione, possono archiviare grandi quantità di informazioni esternamente e recuperarle quando necessario. Questo approccio aiuta gli agenti a gestire flussi di lavoro più lunghi riducendo al contempo i limiti causati dalla dimensione della finestra di contesto.

Per i task complessi che coinvolgono più aree di lavoro, i Deep Agents possono delegare specifici sotto-task a subagent specializzati. Ogni subagent si concentra su un obiettivo definito e restituisce i risultati rilevanti all'agente principale. L'agente principale combina poi gli output dei subagent, le informazioni recuperate e i file archiviati per generare una risposta completa e coerente.

Con funzionalità come pianificazione, uso di strumenti, gestione del filesystem, collaborazione tra subagent e supervisione umana, i LangChain Deep Agents costituiscono le fondamenta per costruire sistemi AI più capaci in grado di gestire task reali e articolati su più passaggi.

Capacità principali dei Deep Agents: pianificazione, strumenti ed esecuzione

I Deep Agents possono gestire task che richiedono più passaggi, decisioni e azioni. Le loro funzionalità principali li aiutano a pianificare il lavoro, usare gli strumenti giusti e completare ogni passaggio in modo efficiente con meno intervento manuale. Vediamo queste capacità in dettaglio:

Pianificazione dei task

La pianificazione dei task consente agli agenti di creare e gestire un elenco strutturato di task durante l'esecuzione. Invece di gestire un obiettivo complesso come un'unica istruzione, gli agenti possono suddividerlo in passaggi più piccoli, monitorare i progressi e aggiornare lo stato dei task durante tutto il flusso di lavoro.

Quando usare la pianificazione

Task lunghi o complicati con più passaggi
Task che beneficiano di un monitoraggio esplicito dei progressi e di un'esecuzione strutturata
Interfacce che mostrano in streaming i progressi dallo stato dell'agente

Come attivarla

Passa TodoListMiddleware al parametro middleware. Questo fornisce all'agente uno strumento write_todos per mantenere un elenco strutturato di task con monitoraggio dello stato (pending, in_progress, completed).

from deepagents import create_deep_agent
from deepagents.middleware import TodoListMiddleware

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

I task vengono conservati nello stato dell'agente, offrendo agli agenti un livello di pianificazione leggero per organizzare il lavoro di lunga durata.

Strumenti per il filesystem virtuale

I Deep Agents offrono un filesystem virtuale configurabile, supportato da backend collegabili: stato in memoria, disco locale, LangGraph store, routing composito o backend personalizzati con regole di autorizzazione.

Strumenti integrati per il filesystem

Strumento	Descrizione
`ls`	Elenca i file in una directory con i relativi metadati (dimensione, data di modifica)
`read_file`	Legge il contenuto dei file con numeri di riga; supporta offset/limit per i file di grandi dimensioni; restituisce anche blocchi di contenuto multimodale per immagini, video, audio e documenti
`write_file`	Crea un nuovo file o sovrascrive uno esistente
`edit_file`	Esegue sostituzioni esatte di stringhe nei file (con modalità di sostituzione globale)
`delete`	Elimina un file o una directory in modo ricorsivo
`glob`	Trova i file che corrispondono a pattern (ad es. `*/.py`)
`grep`	Cerca nel contenuto dei file con diverse modalità di output
`execute`	Esegue comandi shell nell'ambiente (solo backend sandbox)

Estensioni multimodali supportate

Immagine: .png, .jpg, .jpeg, .gif, .webp, .heic, .heif
Video: .mp4, .mpeg, .mov, .avi, .flv, .mpg, .webm, .wmv, .3gpp
Audio: .wav, .mp3, .aiff, .aac, .ogg, .flac
Documento: .pdf, .ppt, .pptx

Permessi del filesystem

Il harness supporta regole di permesso dichiarative che controllano quali file e directory l'agent può leggere o scrivere. Le regole vengono valutate dall'alto verso il basso, con la logica del primo abbinamento vincente.

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"},
    ],
)

Questo permette di limitare gli agent a directory specifiche, proteggere i file sensibili e concedere ai subagent un accesso più ristretto rispetto all'agent principale.

Limitare l'accesso agli strumenti

Puoi esporre solo un sottoinsieme di strumenti del filesystem passando una lista consentita tools a FilesystemMiddleware. read_file deve sempre essere incluso.

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"]),
    ],
)

Subagent (delega)

Il harness include uno strumento integrato task che permette all'agent principale di creare subagent temporanei per attività isolate, di lunga durata, multi-fase o parallele.

Caratteristiche principali

Contesto nuovo: ogni invocazione crea una nuova istanza dell'agent con un proprio contesto
Esecuzione autonoma: il subagent opera in modo indipendente fino al completamento
Passaggio unico: restituisce un unico rapporto finale all'agent principale
Strategia configurabile: usa il subagent predefinito general-purpose oppure definisci subagent personalizzati
Efficienza del contesto: il lavoro intensivo dei sottotask resta isolato e viene compresso in un risultato compatto

Disattivare i subagent

Per eseguire un agent senza lo strumento task, disattiva il subagent aggiunto automaticamente tramite il profilo del harness e non passare subagent sincroni tramite subagents=. Non tentare di rimuovere SubAgentMiddleware tramite excluded_middleware: viene intenzionalmente rifiutato.

Capacità di chiamata degli strumenti

I Deep Agent supportano tre categorie di strumenti:

Funzioni personalizzate e strumenti LangChain

Passa funzioni personalizzate o strumenti LangChain direttamente tramite il parametro 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)

I Deep Agent supportano completamente MCP, permettendo di connettersi a database, API, filesystem e altro tramite un'interfaccia standard.

Esecuzione del codice

Backend sandbox: esponi uno strumento execute per comandi shell in un ambiente isolato
Interpreti: aggiungi uno strumento eval che esegue JavaScript in un runtime QuickJS delimitato, per livelli programmabili leggeri

Man mano che queste funzionalità si combinano, il modello linguistico che alimenta l'agent diventa una parte importante dell'intera configurazione. Un modello capace può aiutare i Deep Agent a comprendere le istruzioni, ragionare sui compiti e utilizzare meglio gli strumenti a disposizione. Kimi API può fornire questo livello di modello, rendendolo un passo naturale per costruire workflow di Deep Agent più capaci.

Collegare Kimi API a LangChain Deep Agents in 6 passaggi

Un modello capace offre al tuo Deep Agent la comprensione linguistica e il ragionamento necessari per gestire i compiti in modo efficace. Kimi API può fornire queste capacità mentre l'agent lavora con gli strumenti, gestisce i compiti e affronta istruzioni complesse. Con il livello del modello pronto, la configurazione può passare naturalmente al collegamento di Kimi API con LangChain Agents. Ecco come collegare Kimi API a LangChain Deep Agents:

Passaggio 1: ottieni la tua Kimi API Key

Accedi alla piattaforma Kimi API e crea una nuova API key. Copiala e conservala in modo sicuro, poiché dovrai aggiungerla alla configurazione dei tuoi Deep Agents. Questa API key autentica le tue richieste e consente ai Deep Agents di LangChain di accedere ai modelli Kimi tramite l'API.

Ottieni la tua Kimi API Key

Passaggio 2: impostare le variabili d'ambiente

Imposta la tua Kimi API key come variabile d'ambiente. Kimi API utilizza l'endpoint API di Moonshot, quindi configura la seguente variabile:

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

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

L'URL di base dell'API è:

https://api.moonshot.ai/v1

https://api.moonshot.ai/v1

Passaggio 3: installare le dipendenze

Installa Deep Agents e le dipendenze LangChain necessarie:

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

Poiché Kimi API è compatibile con OpenAI, langchain-openai consente a LangChain di collegarsi ai modelli Kimi tramite l'interfaccia compatibile con OpenAI.

Se desideri aggiungere funzionalità di ricerca web al tuo Deep Agent, puoi opzionalmente installare Tavily:

pip install tavily-python

pip install tavily-python

Dopo aver creato una API key Tavily dalla piattaforma Tavily, impostala come variabile d'ambiente:

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

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

Tavily è necessario solo se prevedi di aggiungere strumenti di ricerca web al tuo agent.

Passaggio 4: configurare un Deep Agent con Kimi API

Poiché Kimi API è compatibile con il formato dell'API OpenAI, puoi collegarla ai LangChain Deep Agents tramite init_chat_model.

L'esempio seguente crea un Deep Agent di base alimentato da Kimi. Puoi opzionalmente estenderlo con strumenti come la ricerca web.

Deep Agent di base alimentato da 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. """, )

Aggiungere funzionalità di ricerca web (opzionale)

Per attivare la ricerca web, collega uno strumento di ricerca come 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. """, )

Con questa configurazione, i Deep Agents possono usare Kimi come modello di ragionamento pur accedendo a capacità di ricerca esterne tramite Tavily.

Passaggio 5: eseguire il tuo Deep Agent alimentato da Kimi

Una volta configurato il tuo Deep Agent con Kimi, esegui l'agent per verificare come gestisce i compiti e le chiamate agli strumenti.

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)

Passaggio 6: attivare il tracing di LangSmith (opzionale)

Il tracing di LangSmith ti aiuta a monitorare l'esecuzione dell'agent, incluse le chiamate agli strumenti, i passaggi intermedi e le risposte del modello.

Attiva il tracing con le seguenti variabili d'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"

Usa LangSmith quando hai bisogno di maggiore visibilità sui workflow dell'agent, per il debug o per l'analisi delle prestazioni.

Collegare gli agenti con Kimi API

Vantaggi dell'uso di Kimi API

Collegare Kimi API ai Deep Agents può rendere i workflow complessi più capaci e più semplici da gestire. Questa combinazione offre agli agent un ragionamento più solido, consentendo loro di utilizzare strumenti, gestire file e affrontare più compiti. Vediamo i principali vantaggi che questa configurazione può offrire:

Migliorare il ragionamento e l'esecuzione dei compiti dell'agent

I modelli Kimi offrono una solida comprensione linguistica e capacità di ragionamento, aiutando i Deep Agent ad analizzare istruzioni complesse, suddividere i compiti e generare risposte più precise. Ciò consente agli agent di gestire workflow multi-fase in modo più efficace, con meno guida manuale.

Costruire workflow AI più capaci

Con Kimi API collegata ai Deep Agents, gli sviluppatori possono combinare le capacità dei modelli Kimi con strumenti, file system e integrazioni esterne supportate da LangChain. Ciò consente agli agent di eseguire compiti come ricerca, elaborazione di documenti, analisi del codice e gestione dei dati all'interno di un workflow unificato.

Scalare compiti complessi con agent autonomi

I Deep Agents alimentati da Kimi possono gestire compiti di lunga durata creando piani, utilizzando strumenti e delegando sottoattività quando necessario. Ciò rende più semplice costruire applicazioni AI capaci di completare workflow complessi riducendo le operazioni manuali ripetitive.

Conclusione

Costruire agenti AI affidabili parte dalla scelta della base giusta per i flussi di lavoro complessi. LangChain Deep Agents fornisce gli strumenti e la struttura necessari per creare agenti capaci di pianificare, usare tool, gestire il contesto e affrontare attività articolate su più passaggi con meno interventi manuali. Con il modello e la configurazione giusti, gli sviluppatori possono trasformare idee avanzate per gli agenti in applicazioni concrete. Integrando la Kimi API puoi potenziare ulteriormente i tuoi flussi di lavoro con i Deep Agent grazie a capacità solide di ragionamento e di gestione di contesti lunghi. Inizia a esplorare la Kimi API e scopri cosa puoi costruire con gli agenti AI.

Ottieni la tua Kimi API Key

Domande frequenti

Qual è la differenza tra gli agenti LangChain e i Deep Agents?

Gli agenti LangChain forniscono le basi per costruire agenti AI in grado di usare strumenti. I Deep Agents si basano su queste fondamenta con funzionalità aggiuntive come la pianificazione, la gestione dei file, la delega ai subagent e la gestione del contesto. Queste capacità rendono i Deep Agents più adatti a task più lunghi e complessi, e riducono anche la necessità di costruire queste funzionalità separatamente.

Per cosa possono essere usati i LangChain Deep Agents?

I LangChain Deep Agents possono gestire task che richiedono più passaggi, uso di strumenti e decisioni continue. Possono supportare casi d'uso come l'automazione della ricerca, l'analisi di documenti, la comprensione del codice, l'elaborazione dei dati e l'esecuzione di flussi di lavoro complessi. Per i task che coinvolgono più aree di competenza, i Deep Agents possono delegare specifici sotto-task a subagent specializzati e combinare i loro risultati. Collegando i Deep Agents con Kimi API, gli sviluppatori possono creare applicazioni AI che sfruttano le capacità di ragionamento di Kimi e la sua ampia finestra di contesto per task come l'analisi di documenti estesi, l'elaborazione di informazioni complesse e l'automazione di flussi di lavoro ad alta intensità di conoscenza.

Posso aggiungere memoria a un LangChain Deep Agent?

Sì, i LangChain Deep Agents possono supportare la memoria attraverso le integrazioni di persistenza e memoria disponibili. Questo aiuta gli agenti a mantenere le informazioni rilevanti tra interazioni e task, invece di ripartire da zero ogni volta. La memoria può essere utile per flussi di lavoro personalizzati, task di lunga durata e informazioni persistenti.