LangChain 1.0 e Milvus: come costruire agenti pronti per la produzione con una vera memoria a lungo termine

LangChain è un popolare framework open-source per lo sviluppo di applicazioni basate su grandi modelli linguistici (LLM). Fornisce un kit di strumenti modulari per la costruzione di agenti di ragionamento e di utilizzo degli strumenti, per la connessione dei modelli ai dati esterni e per la gestione dei flussi di interazione.

Con il rilascio di LangChain 1.0, il framework fa un passo avanti verso un'architettura più adatta alla produzione. La nuova versione sostituisce il precedente design basato sulla catena con un ciclo ReAct standardizzato (Reason → Tool Call → Observe → Decide) e introduce il Middleware per gestire l'esecuzione, il controllo e la sicurezza.

Tuttavia, il ragionamento da solo non è sufficiente. Gli agenti devono anche avere la capacità di memorizzare, richiamare e riutilizzare le informazioni. È qui che Milvus, un database vettoriale open-source, può svolgere un ruolo essenziale. Milvus fornisce un livello di memoria scalabile e ad alte prestazioni che consente agli agenti di memorizzare, cercare e recuperare le informazioni in modo efficiente attraverso la similarità semantica.

In questo post esploreremo come LangChain 1.0 aggiorna l'architettura degli agenti e come l'integrazione di Milvus aiuta gli agenti ad andare oltre il ragionamento, consentendo una memoria persistente e intelligente per i casi d'uso reali.

Perché il design basato sulle catene non è all'altezza

Agli inizi (versione 0.x), l'architettura di LangChain era incentrata sulle catene. Ogni catena definiva una sequenza fissa e veniva fornita con modelli precostituiti che rendevano l'orchestrazione di LLM semplice e veloce. Questo design era ottimo per costruire rapidamente prototipi. Ma con l'evoluzione dell'ecosistema LLM e l'aumento della complessità dei casi d'uso reali, questa architettura ha iniziato a presentare delle crepe.

1. Mancanza di flessibilità

Le prime versioni di LangChain fornivano pipeline modulari come SimpleSequentialChain o LLMChain, ognuna delle quali seguiva un flusso fisso e lineare: creazione del prompt → chiamata al modello → elaborazione dell'output. Questa struttura ha funzionato bene per compiti semplici e prevedibili e ha reso facile la prototipazione rapida.

Tuttavia, quando le applicazioni sono diventate più dinamiche, questi modelli rigidi hanno cominciato a sembrare restrittivi. Quando la logica aziendale non si adatta più perfettamente a una sequenza predefinita, ci si trova di fronte a due opzioni insoddisfacenti: forzare la logica a conformarsi al framework o aggirarlo completamente chiamando direttamente l'API LLM.

2. Mancanza di controllo di livello produttivo

Ciò che funzionava bene nelle demo spesso si rompeva in produzione. Le catene non includono le salvaguardie necessarie per applicazioni su larga scala, persistenti o sensibili. I problemi più comuni sono stati:

• Overflow del contesto: Le conversazioni lunghe potevano superare i limiti dei token, causando crash o troncamenti silenziosi.

• Perdite di dati sensibili: Le informazioni di identificazione personale (come e-mail o ID) potrebbero essere inviate inavvertitamente a modelli di terze parti.

• Operazioni non supervisionate: Gli agenti potrebbero cancellare dati o inviare e-mail senza l'approvazione umana.

3. Mancanza di compatibilità tra modelli

Ogni fornitore di LLM - OpenAI, Anthropic e molti modelli cinesi - implementa i propri protocolli per il ragionamento e la chiamata agli strumenti. Ogni volta che si cambia fornitore, si deve riscrivere il livello di integrazione: modelli di prompt, adattatori e parser di risposta. Questo lavoro ripetitivo rallentava lo sviluppo e rendeva dolorosa la sperimentazione.

LangChain 1.0: Agente ReAct all-in

Quando il team di LangChain ha analizzato centinaia di implementazioni di agenti in produzione, è emersa un'intuizione: quasi tutti gli agenti di successo convergevano naturalmente sul modello ReAct ("Reasoning + Acting").

Che si tratti di un sistema multi-agente o di un singolo agente che esegue un ragionamento approfondito, emerge lo stesso ciclo di controllo: alternare brevi fasi di ragionamento con chiamate mirate agli strumenti, quindi alimentare le osservazioni risultanti nelle decisioni successive fino a quando l'agente può fornire una risposta finale.

Per basarsi su questa struttura collaudata, LangChain 1.0 pone il ciclo ReAct al centro della sua architettura, rendendolo la struttura predefinita per costruire agenti affidabili, interpretabili e pronti per la produzione.

Per supportare qualsiasi cosa, dagli agenti semplici alle orchestrazioni complesse, LangChain 1.0 adotta un design a strati che combina facilità d'uso e controllo preciso:

• Scenari standard: Iniziare con la funzione create_agent(), un ciclo ReAct pulito e standardizzato che gestisce il ragionamento e le chiamate agli strumenti.

• Scenari estesi: Aggiungete il Middleware per ottenere un controllo a grana fine. Il middleware consente di ispezionare o modificare ciò che accade all'interno dell'agente, ad esempio aggiungendo il rilevamento di PII, i checkpoint di approvazione umana, i tentativi automatici o i ganci di monitoraggio.

• Scenari complessi: Per i flussi di lavoro statici o l'orchestrazione di più agenti, utilizzate LangGraph, un motore di esecuzione basato su grafi che fornisce un controllo preciso sul flusso logico, sulle dipendenze e sugli stati di esecuzione.

Ora analizziamo i tre componenti chiave che rendono lo sviluppo degli agenti più semplice, sicuro e coerente tra i vari modelli.

1. Il metodo create_agent(): Un modo più semplice di costruire gli agenti

Una novità fondamentale di LangChain 1.0 è la riduzione della complessità della costruzione degli agenti a un'unica funzione, create_agent(). Non è più necessario gestire manualmente la gestione dello stato, la gestione degli errori o lo streaming delle uscite. Queste caratteristiche di livello produttivo sono ora gestite automaticamente dal runtime LangGraph sottostante.

Con soli tre parametri, è possibile lanciare un agente completamente funzionale:

• model - un identificatore di modello (stringa) o un oggetto modello istanziato.

• tools - un elenco di funzioni che danno all'agente le sue capacità.

• system_prompt - l'istruzione che definisce il ruolo, il tono e il comportamento dell'agente.

Sotto il cofano, create_agent() esegue il ciclo standard dell'agente: chiama un modello, gli lascia scegliere gli strumenti da eseguire e termina quando non sono più necessari strumenti:

Inoltre, eredita le funzionalità integrate di LangGraph per la persistenza dello stato, il recupero delle interruzioni e lo streaming. Attività che un tempo richiedevano centinaia di righe di codice di orchestrazione sono ora gestite attraverso un'unica API dichiarativa.

from langchain.agents import create_agent
agent = create_agent(
    model="openai:gpt-4o",
    tools=[get_weather, query_database],
    system_prompt="You are a customer service assistant who helps users check the weather and order information."
)
result = agent.invoke({
    "messages": [{"role": "user", "content": "What’s the weather like in Shanghai today?"}]
})

2. Il middleware: Uno strato componibile per un controllo pronto per la produzione

Il middleware è il ponte chiave che porta LangChain dal prototipo alla produzione. Espone ganci in punti strategici del ciclo di esecuzione dell'agente, consentendo di aggiungere logica personalizzata senza riscrivere il processo principale di ReAct.

Il ciclo principale di un agente segue un processo decisionale in tre fasi: Modello → Strumento → Terminazione:

LangChain 1.0 fornisce alcuni middleware precostituiti per modelli comuni. Ecco quattro esempi.

• Rilevamento di PII: Qualsiasi applicazione che gestisce dati sensibili dell'utente

from langchain.agents import create_agent
from langchain.agents.middleware import PIIMiddleware
agent = create_agent(
model=“gpt-4o”,
tools=[],  # Add tools as needed
middleware=[
# Redact emails in user input
PIIMiddleware(“email”, strategy=“redact”, apply_to_input=True),
# Mask credit cards (show last 4 digits)
PIIMiddleware(“credit_card”, strategy=“mask”, apply_to_input=True),
# Custom PII type with regex
PIIMiddleware(
“api_key”,
detector=r"sk-[a-zA-Z0-9]{32}",
strategy=“block”,  # Raise error if detected
),
],
)

• Riassunto: Riassumere automaticamente la cronologia delle conversazioni quando si avvicinano i limiti dei token.

from langchain.agents import create_agent
from langchain.agents.middleware import SummarizationMiddleware
agent = create_agent(
model=“gpt-4o”,
tools=[weather_tool, calculator_tool],
middleware=[
SummarizationMiddleware(
model=“gpt-4o-mini”,  #Summarize using a cheaper model  
max_tokens_before_summary=4000,  # Trigger summarization at 4000 tokens
messages_to_keep=20,  # Keep last 20 messages after summary
),
],
)

• Riproduzione dello strumento: Riproduzione automatica delle chiamate allo strumento fallite con backoff esponenziale configurabile.

from langchain.agents import create_agent
from langchain.agents.middleware import ToolRetryMiddleware
agent = create_agent(
    model="gpt-4o",
    tools=[search_tool, database_tool],
    middleware=[
        ToolRetryMiddleware(
            max_retries=3,  # Retry up to 3 times
            backoff_factor=2.0,  # Exponential backoff multiplier
            initial_delay=1.0,  # Start with 1 second delay
            max_delay=60.0,  # Cap delays at 60 seconds
            jitter=True,  # Add random jitter to avoid thundering herd (±25%)
    ),
],

)

• Middleware personalizzato

Oltre alle opzioni di middleware ufficiali e precostituite, è possibile creare middleware personalizzati utilizzando metodi basati su decoratori o classi.

Ad esempio, lo snippet seguente mostra come registrare le chiamate al modello prima dell'esecuzione:

from langchain.agents.middleware import before_model
from langchain.agents.middleware import AgentState
from langgraph.runtime import Runtime
@before_model
def log_before_model(state: AgentState, runtime: Runtime) -> dict | None:
    print(f"About to call model with {len(state['messages'])} messages")
    return None  # Returning None means the normal flow continues
agent = create_agent(
    model="openai:gpt-4o",
    tools=[...],
    middleware=[log_before_model],
)

3. Output strutturato: Un modo standardizzato di gestire i dati

Nello sviluppo tradizionale di agenti, l'output strutturato è sempre stato difficile da gestire. Ogni fornitore di modelli lo gestisce in modo diverso: ad esempio, OpenAI offre un'API nativa per l'output strutturato, mentre altri supportano le risposte strutturate solo indirettamente, tramite chiamate a strumenti. Questo spesso significava scrivere adattatori personalizzati per ogni fornitore, aggiungendo lavoro extra e rendendo la manutenzione più dolorosa del dovuto.

In LangChain 1.0, l'output strutturato è gestito direttamente attraverso il parametro response_format in create_agent(). È sufficiente definire lo schema dei dati una sola volta. LangChain sceglie automaticamente la migliore strategia di applicazione in base al modello in uso, senza bisogno di ulteriori impostazioni o codice specifico del fornitore.

from langchain.agents import create_agent
from pydantic import BaseModel, Field
class WeatherReport(BaseModel):
    location: str = Field(description="City name")
    temperature: float = Field(description="Temperature (°C)")
    condition: str = Field(description="Weather condition")
agent = create_agent(
    model="openai:gpt-4o",
    tools=[get_weather],
    response_format=WeatherReport  # Use the Pydantic model as the response schema
)
result = agent.invoke({"role": "user", "content": "What’s the weather like in Shanghai today??"})
weather_data = result['structured_response']  # Retrieve the structured response
print(f"{weather_data.location}: {weather_data.temperature}°C, {weather_data.condition}")

LangChain supporta due strategie per l'output strutturato:

1. Strategia del fornitore: Alcuni fornitori di modelli supportano nativamente l'output strutturato attraverso le loro API (ad esempio OpenAI e Grok). Quando tale supporto è disponibile, LangChain utilizza direttamente l'applicazione dello schema incorporato del fornitore. Questo approccio offre il massimo livello di affidabilità e coerenza, poiché il modello stesso garantisce il formato di output.

2. Strategia di chiamata dello strumento: Per i modelli che non supportano l'output strutturato nativo, LangChain utilizza la chiamata agli strumenti per ottenere lo stesso risultato.

Non è necessario preoccuparsi della strategia utilizzata: il framework rileva le capacità del modello e si adatta automaticamente. Questa astrazione consente di passare liberamente da un fornitore di modelli all'altro senza modificare la logica aziendale.

Come Milvus migliora la memoria degli agenti

Per gli agenti di livello produttivo, il vero collo di bottiglia delle prestazioni spesso non è il motore di ragionamento, ma il sistema di memoria. In LangChain 1.0, i database vettoriali agiscono come memoria esterna dell'agente, fornendo un richiamo a lungo termine attraverso il recupero semantico.

Milvus è uno dei database vettoriali open-source più maturi oggi disponibili, costruito appositamente per la ricerca vettoriale su larga scala nelle applicazioni di IA. Si integra in modo nativo con LangChain, in modo da non dover gestire manualmente la vettorializzazione, la gestione degli indici o la ricerca di similarità. Il pacchetto langchain_milvus racchiude Milvus come un'interfaccia standard di VectorStore, consentendo di collegarlo ai propri agenti con poche righe di codice.

In questo modo, Milvus affronta tre sfide fondamentali nella costruzione di sistemi di memoria per agenti scalabili e affidabili:

1. Recupero rapido da basi di conoscenza enormi

Quando un agente deve elaborare migliaia di documenti, conversazioni passate o manuali di prodotti, la semplice ricerca per parole chiave non è sufficiente. Milvus utilizza la ricerca per similarità vettoriale per trovare informazioni semanticamente rilevanti in pochi millisecondi, anche se la query utilizza parole diverse. Questo permette al vostro agente di richiamare le conoscenze in base al significato, non solo alle corrispondenze esatte del testo.

from langchain.agents import create_agent
from langchain_milvus import Milvus
from langchain_openai import OpenAIEmbeddings
# Initialize the vector database as a knowledge base
vectorstore = Milvus(
    embedding=OpenAIEmbeddings(),  
    collection_name="company_knowledge",
    connection_args={"uri": "http://localhost:19530"}  #
)
# Convert the retriever into a Tool for the Agent
agent = create_agent(
    model="openai:gpt-4o",
    tools=[vectorstore.as_retriever().as_tool(
        name="knowledge_search",
        description="Search the company knowledge base to answer professional questions"
    )],
    system_prompt="You can retrieve information from the knowledge base to answer questions."
)

2. Memoria persistente a lungo termine

Il riassunto di LangChain può condensare la storia della conversazione quando diventa troppo lunga, ma cosa succede a tutti i dettagli che vengono riassunti? Milvus li conserva. Ogni conversazione, chiamata allo strumento e fase di ragionamento può essere vettorializzata e archiviata per un riferimento a lungo termine. In caso di necessità, l'agente può recuperare rapidamente i ricordi pertinenti attraverso la ricerca semantica, consentendo una vera continuità tra le sessioni.

from langchain_milvus import Milvus
from langchain.agents import create_agent
from langchain.agents.middleware import SummarizationMiddleware
from langgraph.checkpoint.memory import InMemorySaver
# Long-term memory storage(Milvus)
long_term_memory = Milvus.from_documents(
    documents=[],  # Initially empty; dynamically updated at runtime
    embedding=OpenAIEmbeddings(),
    connection_args={"uri": "./agent_memory.db"}
)
# Short-term memory management(LangGraph Checkpointer + Summarization)
agent = create_agent(
    model="openai:gpt-4o",
    tools=[long_term_memory.as_retriever().as_tool(
        name="recall_memory",
        description="Retrieve the agent’s historical memories and past experiences"
    )],
    checkpointer=InMemorySaver(),  # Short-term memory
    middleware=[
        SummarizationMiddleware(
            model="openai:gpt-4o-mini",
            max_tokens_before_summary=4000  # When the threshold is exceeded, summarize and store it in Milvus
        )
    ]
)

3. Gestione unificata dei contenuti multimodali

Gli agenti moderni non gestiscono solo il testo, ma interagiscono anche con immagini, audio e video. Milvus supporta la memorizzazione multivettoriale e lo schema dinamico, consentendo di gestire le incorporazioni di più modalità in un unico sistema. Questo fornisce una base di memoria unificata per gli agenti multimodali, consentendo un recupero coerente tra i diversi tipi di dati.

# Filter retrievals by source (e.g., search only medical reports)
vectorstore.similarity_search(
    query="What is the patient's blood pressure reading?",
    k=3,
    expr="source == 'medical_reports' AND modality == 'text'"  # Milvus scalar filtering
)

LangChain vs. LangGraph: Come scegliere quello più adatto ai vostri agenti

L'aggiornamento a LangChain 1.0 è un passo essenziale per la creazione di agenti di livello produttivo, ma ciò non significa che sia sempre l'unica o la migliore scelta per ogni caso d'uso. La scelta del framework giusto determina la velocità con cui è possibile combinare queste funzionalità in un sistema funzionante e manutenibile.

In realtà, LangChain 1.0 e LangGraph 1.0 possono essere visti come parte della stessa struttura a strati, progettati per lavorare insieme piuttosto che per sostituirsi l'un l'altro: LangChain aiuta a costruire rapidamente agenti standard, mentre LangGraph offre un controllo a grana fine per flussi di lavoro complessi. In altre parole, LangChain aiuta a muoversi velocemente, mentre LangGraph aiuta ad andare in profondità.

Di seguito è riportato un rapido confronto delle differenze di posizionamento tecnico:

Dimensione	LangChain 1.0	LangChain 1.0
Livello di astrazione	Astrazione di alto livello, progettata per scenari di agenti standard	Quadro di orchestrazione di basso livello, progettato per flussi di lavoro complessi
Capacità di base	Ciclo ReAct standard (Motivo → Chiamata allo strumento → Osservazione → Risposta)	Macchine a stati personalizzate e logica di ramificazione complessa (StateGraph + Routing condizionale)
Meccanismo di estensione	Middleware per funzionalità di livello produttivo	Gestione manuale di nodi, bordi e transizioni di stato
Implementazione sottostante	Gestione manuale di nodi, bordi e transizioni di stato	Runtime nativo con persistenza e recupero integrati
Casi d'uso tipici	80% degli scenari standard degli agenti	Collaborazione tra più agenti e orchestrazione di flussi di lavoro di lunga durata
Curva di apprendimento	Costruire un agente in ~10 righe di codice	Richiede la comprensione dei grafi di stato e dell'orchestrazione dei nodi

Se siete alle prime armi con la creazione di agenti o volete avviare rapidamente un progetto, iniziate con LangChain. Se sapete già che il vostro caso d'uso richiede un'orchestrazione complessa, una collaborazione tra più agenti o flussi di lavoro di lunga durata, passate direttamente a LangGraph.

Entrambi i framework possono coesistere nello stesso progetto: si può iniziare in modo semplice con LangChain e introdurre LangGraph quando il sistema ha bisogno di maggiore controllo e flessibilità. La chiave è scegliere lo strumento giusto per ogni parte del flusso di lavoro.

Conclusione

Tre anni fa, LangChain è nato come un wrapper leggero per chiamare gli LLM. Oggi si è trasformato in un framework completo e di livello produttivo.

Gli strati di middleware forniscono sicurezza, conformità e osservabilità. LangGraph aggiunge l'esecuzione persistente, il flusso di controllo e la gestione dello stato. E a livello di memoria, Milvus colma una lacuna critica: fornisce una memoria a lungo termine scalabile e affidabile che consente agli agenti di recuperare il contesto, ragionare sulla storia e migliorare nel tempo.

Insieme, LangChain, LangGraph e Milvus formano una catena di strumenti pratici per l'era moderna degli agenti, che unisce la prototipazione rapida alla distribuzione su scala aziendale, senza sacrificare l'affidabilità o le prestazioni.

🚀 Siete pronti a dare al vostro agente una memoria affidabile e a lungo termine? Esplorate Milvus e scoprite come alimenta una memoria intelligente e a lungo termine per gli agenti LangChain in produzione.

Avete domande o volete un approfondimento su una qualsiasi funzione? Unitevi al nostro canale Discord o inviate problemi su GitHub. È anche possibile prenotare una sessione individuale di 20 minuti per ottenere approfondimenti, indicazioni e risposte alle vostre domande attraverso Milvus Office Hours.