Agenti LangChain nel 2026: ReAct, LangGraph e Production Patterns

AgentExecutor vs. LangGraph: cosa è cambiato e perché è importante

Per comprendere il percorso di migrazione è necessario comprendere il motivo per cui AgentExecutor è stato ritirato. Non era arbitrario: colpiva i limiti architettonici fondamentali quando gli sviluppatori cercavano di costruire sistemi di produzione.

La limitazione più dolorosa di AgentExecutor era l'impossibilità di mettere in pausa a metà corsa e riprendere in seguito. Qualsiasi flusso di lavoro reale - si pensi a "redigere un rapporto, attendere l'approvazione umana, quindi pubblicare" - richiede uno stato persistente oltre i limiti temporali. Il checkpointer di LangGraph risolve questo problema in modo nativo.

Il modello ReAct: ragionare + agire in un ciclo

ReAct (Reason + Act) è il modello di suggerimento fondamentale dietro la maggior parte degli agenti LangChain. Indica al LLM di alternare due modalità: Thought (ragionamento interno su cosa fare dopo) e Azione (chiamando uno strumento specifico con argomenti specifici).

In pratica il ciclo si presenta così:

1. Thought: Il LLM ragiona sulla richiesta dell'utente e sugli strumenti disponibili.
2. Action: LLM genera una chiamata di strumento strutturato (nome + argomenti).
3. Observation: Lo strumento esegue e restituisce un risultato, aggiunto al contesto.
4. Thought again: Il LLM ragiona sull'osservazione.
5. Risposta finale: Quando LLM determina di disporre di informazioni sufficienti, restituisce la risposta finale.

In LangGraph, ciascuno di questi passaggi è a nodo in un grafico. Il bordo condizionale dopo la verifica del nodo LLM: "il modello ha chiamato uno strumento o ha prodotto una risposta finale?" - e percorsi di conseguenza. Ciò rende il ciclo ReAct esplicito e ispezionabile anziché implicito all'interno di un esecutore black-box.

I moderni LLM (GPT-4o, Claude 3.7, Gemini 2.5) gestiscono ReAct in modo nativo attraverso le loro API di chiamata di funzioni/utilizzo di strumenti. Non è più necessario formattare manualmente le stringhe "Thought/Action/Observation": la funzionalità di utilizzo degli strumenti del modello gestisce questa operazione a livello API. LangGraph completa tutto questo in modo pulito in modo che i tuoi nodi rimangano concentrati sulla logica aziendale.

Building a LangGraph Agent Step by Step

Ecco il modello di agente LangGraph minimo in Python. Ogni agente produttivo è una variazione di questo scheletro.

1. Define State

Lo Stato è l’unica fonte di verità che scorre attraverso ogni nodo. Utilizza TypedDict o un modello Pydantic:

from typing import Annotated, Sequence
from langchain_core.messages import BaseMessage
from langgraph.graph.message import add_messages
from typing_extensions import TypedDict

class AgentState(TypedDict):
    messages: Annotated[Sequence[BaseMessage], add_messages]
    # add any custom fields your agent needs
    context: str
    iteration_count: int

2. Define Tools

Gli strumenti sono semplici funzioni Python decorate con @tool. La docstring diventa la descrizione dello strumento che LLM vede:

from langchain_core.tools import tool

@tool
def search_web(query: str) -> str:
    """Search the web for current information about a topic."""
    # your search implementation here
    return results

@tool
def write_file(filename: str, content: str) -> str:
    """Write content to a file on disk."""
    with open(filename, 'w') as f:
        f.write(content)
    return f"Written {len(content)} chars to {filename}"

tools = [search_web, write_file]

3. Build the Graph

from langgraph.graph import StateGraph, END
from langgraph.prebuilt import ToolNode
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o").bind_tools(tools)

def agent_node(state: AgentState):
    response = llm.invoke(state["messages"])
    return {"messages": [response]}

def should_continue(state: AgentState):
    last_message = state["messages"][-1]
    if last_message.tool_calls:
        return "tools"
    return END

graph = StateGraph(AgentState)
graph.add_node("agent", agent_node)
graph.add_node("tools", ToolNode(tools))
graph.set_entry_point("agent")
graph.add_conditional_edges("agent", should_continue)
graph.add_edge("tools", "agent")

app = graph.compile()

4. Add a Checkpointer per persistenza

from langgraph.checkpoint.sqlite import SqliteSaver

checkpointer = SqliteSaver.from_conn_string("./agent_memory.db")
app = graph.compile(checkpointer=checkpointer)

# Now every run is persisted and resumable
config = {"configurable": {"thread_id": "user-session-123"}}
result = app.invoke({"messages": [("human", "Research LangGraph and write a summary")]}, config)

LangGraph in JavaScript / TypeScript: parità di funzionalità completa

A partire dal 2026, @langchain/langgraph ha la piena parità di funzionalità con Python SDK. Se stai creando backend Node.js, azioni server Next.js o percorsi API Nuxt, sei completamente supportato.

import { StateGraph, END } from "@langchain/langgraph";
import { ChatOpenAI } from "@langchain/openai";
import { tool } from "@langchain/core/tools";
import { z } from "zod";

// Define a tool with Zod schema
const searchWeb = tool(
  async ({ query }) => {
    const results = await yourSearchFunction(query);
    return results;
  },
  {
    name: "search_web",
    description: "Search the web for current information",
    schema: z.object({ query: z.string() }),
  }
);

// State type
interface AgentState {
  messages: BaseMessage[];
}

const llm = new ChatOpenAI({ model: "gpt-4o" }).bindTools([searchWeb]);

// Build graph — identical pattern to Python
const graph = new StateGraph<AgentState>({ channels: messagesStateReducer })
  .addNode("agent", async (state) => ({
    messages: [await llm.invoke(state.messages)],
  }))
  .addNode("tools", new ToolNode([searchWeb]))
  .addEdge("__start__", "agent")
  .addConditionalEdges("agent", shouldContinue)
  .addEdge("tools", "agent");

const app = graph.compile();

L'SDK JS/TS supporta gli stessi checkpointer (in memoria per lo sviluppo, PostgreSQL per la produzione), la stessa API di streaming (streamEvents) e la stessa integrazione di traccia LangSmith. Il modello mentale si trasferisce direttamente tra le lingue.

Architetture multi-agente: orchestratori e sottografi

I sistemi ad agente singolo raggiungono rapidamente i limiti: le finestre di contesto si traboccano, la specializzazione ne risente e le attività complesse richiedono coordinamento. Nel 2026, le distribuzioni di produzione LangGraph utilizzano quasi sempre modelli multi-agente.

I tre modelli fondamentali

LangGraph implementa sistemi multi-agente attraverso composizione del sottografo. Ogni agente specializzato è un grafico compilato che viene incorporato come nodo nel grafico dell'orchestratore padre. Lo stato può fluire tra i livelli e ogni sottografo può avere il proprio checkpoint e la propria memoria.

Production Patterns: quali demo di giocattoli non ti mostrano

Far funzionare un agente LangGraph in un notebook Jupyter è una cosa. Gestirlo in modo affidabile su larga scala è un altro. Ecco i modelli che separano il prototipo dalla produzione.

Error Handling and Retry Logic

I guasti degli strumenti sono inevitabili: limiti di velocità, timeout di rete, output non validi. LangGraph offre due leve: try/catch a livello di nodo che restituisce un messaggio di errore a LLM (permettendogli di eseguire il ripristino senza problemi) e policy di ripetizione dei tentativi a livello di grafico sui bordi.

Iteration Limits

Imposta sempre recursion_limit durante la compilazione. Senza di esso, un LLM confuso può ripetersi indefinitamente e bruciare il budget API. Un valore predefinito ragionevole è 25 iterazioni per la maggior parte delle attività.

app = graph.compile(checkpointer=checkpointer)
# Invoke with recursion limit
result = app.invoke(
    {"messages": [("human", query)]},
    config={"recursion_limit": 25, "configurable": {"thread_id": thread_id}}
)

Interruzioni Human-in-the-Loop

Le opzioni di compilazione interrupt_before e interrupt_after di LangGraph ti consentono di sospendere l'esecuzione su nodi specifici, mostrare lo stato corrente a un essere umano, raccogliere input e riprendere. Ciò è indispensabile per i flussi di lavoro di approvazione, i controlli di revisione dei contenuti e le chiamate a strumenti ad alto rischio.

Streaming per UX in tempo reale

Per le applicazioni rivolte agli utenti, lo streaming non è negoziabile. astream_events di LangGraph fornisce eventi granulari: quale nodo è in esecuzione, quale strumento è stato chiamato e output LLM token per token. Collegalo a Server-Sent Events (SSE) o WebSocket per progressi in tempo reale nella tua interfaccia utente.

Observability with LangSmith

Imposta LANGCHAIN_TRACING_V2=true e ogni esecuzione dell'agente ottiene una traccia completa: quali nodi sono stati attivati, cosa ha visto LLM, cosa ha restituito ciascuno strumento, latenza totale e costi dei token. In questo modo è possibile eseguire il debug del messaggio "perché ha chiamato lo strumento sbagliato?" classe di bug di produzione - non istruzioni di stampa.

Real-World LangChain Agent Use Cases in 2026

I modelli sopra indicati sbloccano un'ampia gamma di applicazioni di produzione. Ecco le categorie in cui gli agenti LangGraph offrono oggi valore reale.

Come scegliere l'architettura dell'agente giusta per il tuo caso d'uso

Non tutti i problemi necessitano di un grafico multi-agente complesso. Ecco un quadro decisionale basato su ciò che stai effettivamente cercando di costruire.

Un’euristica pratica: inizia con il modello più semplice che potrebbe funzionare, strumentalo con LangSmith, quindi identifica il collo di bottiglia. Gli ingegneri che progettano in anticipo tenendo conto della complessità quasi sempre sovraccaricano il loro primo sistema ad agente. I modelli in LangGraph facilitano il passaggio ad architetture più complesse man mano che i requisiti diventano chiari.

Frequently Asked Questions

Considerazioni finali: LangGraph sarà l'agente standard nel 2026

Gli "agenti LangChain" che dovresti creare nel 2026 sono macchine a stati LangGraph. L'era deprecata AgentExecutor è finita. Lo stato esplicito di LangGraph, il routing condizionale, il checkpoint persistente e la composizione multi-agente nativa non sono piacevoli da avere: sono prerequisiti per qualsiasi cosa di cui ti fidi nella produzione.

Il modello ReAct rimane il giusto punto di partenza per la maggior parte delle attività. Aggiungi la complessità multi-agente solo quando un singolo agente raggiunge in modo dimostrabile i suoi limiti. Gestisci tutto con LangSmith fin dal primo giorno: il debug senza tracce è il modo più veloce per sprecare una settimana su un problema che richiede 10 minuti per essere diagnosticato con visibilità.

Il cambiamento più importante è concettuale: gli agenti LangGraph non sono chatbot con strumenti integrati. Sono sistemi con stato e persistenti in cui un LLM guida il flusso di controllo. Progettali come sistemi distribuiti, con modalità di errore, logica di ripetizione, confini di stato e osservabilità, e ti ricompenseranno con un'affidabilità che sorprenderà anche gli ingegneri esperti.

Se stai creando automazione dei contenuti, pipeline SEO o flussi di lavoro di ricerca in più fasi, EasyClaw è il modo più veloce per vedere questi modelli in azione, senza spendere settimane a cablare personalmente l'infrastruttura.