Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Catena Profonda di Agenti

Lezione 15 di 18 Aggiornata il 28 luglio 2026 Sviluppatore
In questa pagina
  1. Catene di Agenti Illimitate
  2. Tre Topologie e le Loro Implicazioni
  3. Due Pipeline di Produzione
  4. Mantenere la Profondità Ragionevole
  5. Punti chiave

Catene di Agenti Illimitate

Le API Mistral Agents non impongono alcun limite di profondità alla catena di agenti. Un agente può passare il compito a un secondo, che lo passa a un terzo, e così via. Questa libertà consente flussi di lavoro complessi e modulari, ma pone anche su di te la responsabilità della topologia: sei tu a decidere chi può chiamare chi. Questa mappa determina il comportamento del sistema tanto quanto le istruzioni per ogni singolo agente.

Tre Topologie e le Loro Implicazioni

La catena lineare è lo schema più semplice: ogni agente passa il compito al successivo senza diramazioni.

Agente A → Agente B → Agente C → Risposta

Questo approccio è ideale per processi in cui l’ordine è noto in anticipo e non cambia mai. Un esempio tipico è: ricerca, poi analisi, poi stesura; non scrivi prima di analizzare e non analizzi prima di cercare.

# Agente di ricerca
research = client.beta.agents.create(
    model="mistral-large-latest",
    name="research",
    description="Search for factual information.",
    tools=[{"type": "web_search"}]
)

# Agente di analisi
analyst = client.beta.agents.create(
    model="mistral-large-latest",
    name="analyst",
    description="Analyze data and extract insights.",
    tools=[{"type": "code_interpreter"}]
)

# Agente di stesura
writer = client.beta.agents.create(
    model="mistral-large-latest",
    name="writer",
    description="Draft professional reports.",
    instructions="Write a structured report based on the analyzed data."
)

# Catena: research → analyst → writer
research = client.beta.agents.update(
    agent_id=research.id,
    handoffs=[analyst.id]
)

analyst = client.beta.agents.update(
    agent_id=analyst.id,
    handoffs=[writer.id]
)

Ogni agente conosce solo il suo successore immediato: research non sa nemmeno che writer esiste. La catena esiste solo nelle chiamate update, nowhere else.

La catena a stella risponde all’esigenza opposta: un router centrale distribuisce i compiti a specialisti che non comunicano tra loro.

          ┌→ Agente Ricerca Web
Router ──┼→ Agente Calcolatrice
          └→ Agente Stesura
router = client.beta.agents.create(
    model="mistral-large-latest",
    name="router",
    description="Orchestrate requests.",
    handoffs=[research.id, analyst.id, writer.id]
)

Qui l’ordine non è predeterminato: è la richiesta stessa a decidere la destinazione. Questa forma si adatta ad assistenti versatili in cui ogni richiesta rientra in una competenza specifica.

La topologia ibrida combina entrambe: il router distribuisce e gli specialisti possono anche passarsi il compito a vicenda.

          ┌→ Agente Ricerca ──→ Agente Analisi
Router ──┤                          │
          └→ Agente Stesura ←───────────┘
# Research può passare ad Analyst
research = client.beta.agents.update(
    agent_id=research.id,
    handoffs=[analyst.id]
)

# Analyst può passare a Writer
analyst = client.beta.agents.update(
    agent_id=analyst.id,
    handoffs=[writer.id]
)

# Router può accedere a tutti
router = client.beta.agents.update(
    agent_id=router.id,
    handoffs=[research.id, analyst.id, writer.id]
)

Questa è la forma più potente, ma anche la più difficile da debuggare. La stessa richiesta può seguire percorsi diversi da un’esecuzione all’altra, rendendo essenziale la registrazione dei passaggi di consegna (handoff logging) una volta usciti dalla sandbox.

Due Pipeline di Produzione

L’elaborazione dei dati illustra la catena lineare nel suo caso d’uso più naturale: raccolta, pulizia, visualizzazione. Gli ultimi due passaggi utilizzano lo stesso strumento, ma separarli mantiene pulito ogni insieme di istruzioni: pulire e rappresentare sono compiti distinti.

# Passaggio 1: Raccolta
collector = client.beta.agents.create(
    model="mistral-large-latest",
    name="data-collector",
    description="Collect data from the internet.",
    tools=[{"type": "web_search"}]
)

# Passaggio 2: Pulizia e trasformazione
transformer = client.beta.agents.create(
    model="mistral-large-latest",
    name="data-transformer",
    description="Clean and transform raw data.",
    tools=[{"type": "code_interpreter"}]
)

# Passaggio 3: Analisi e visualizzazione
visualizer = client.beta.agents.create(
    model="mistral-large-latest",
    name="data-visualizer",
    description="Create visualizations and charts.",
    tools=[{"type": "code_interpreter"}]
)

# Catena
collector = client.beta.agents.update(agent_id=collector.id, handoffs=[transformer.id])
transformer = client.beta.agents.update(agent_id=transformer.id, handoffs=[visualizer.id])

Un assistente di ricerca accademica segue la stessa struttura, ma con un tipo diverso di collegamento intermedio. Il sintetizzatore non ha strumenti: il suo valore risiede interamente nelle sue istruzioni, che gli chiedono di confrontare le fonti – punti in comune, divergenze, lacune – invece di limitarsi ad accumularle.

# Ricercatore
searcher = client.beta.agents.create(
    model="mistral-large-latest",
    name="academic-searcher",
    description="Search for academic articles and publications.",
    tools=[{"type": "web_search"}]
)

# Sintetizzatore
synthesizer = client.beta.agents.create(
    model="mistral-large-latest",
    name="synthesizer",
    description="Synthesize and compare multiple sources.",
    instructions="Identify common points, divergences, and gaps."
)

# Scrittore accademico
academic_writer = client.beta.agents.create(
    model="mistral-large-latest",
    name="academic-writer",
    description="Structured academic writing with citations.",
    instructions="Write in academic format with introduction, methodology, results, discussion."
)

# Pipeline: searcher → synthesizer → writer
searcher = client.beta.agents.update(agent_id=searcher.id, handoffs=[synthesizer.id])
synthesizer = client.beta.agents.update(agent_id=synthesizer.id, handoffs=[academic_writer.id])

Mantenere la Profondità Ragionevole

L’assenza di un limite tecnico non è un invito a esagerare. In pratica, concatenare da due a quattro agenti copre la stragrande maggioranza delle esigenze. Oltre i cinque, sia la latenza che i costi aumentano drasticamente. La ragione è meccanica: ogni agente aggiunge i propri token di contesto, incluse le istruzioni, a una cronologia conversazionale che è cresciuta solo dal primo passaggio di consegna. Un quinto agente non lavora sulla richiesta iniziale, ma su tutto ciò che i precedenti quattro hanno prodotto.

Prima di allungare una catena, chiediti se il passaggio extra merita un agente dedicato o se rientra nelle istruzioni di un agente esistente. Una direttiva di formattazione, ad esempio, quasi mai giustifica un anello aggiuntivo.

Nota inoltre che un agente non è limitato a un singolo target. Può dichiarare più target e scegliere in base al contesto.

analyst = client.beta.agents.update(
    agent_id=analyst.id,
    handoffs=[writer.id, visualizer.id, calculator.id]
)

Questo analista instraderà allo scrittore se il risultato è pronto per essere comunicato, al visualizzatore se i dati richiedono un grafico, o alla calcolatrice se manca ancora una cifra. La scelta si basa, come sempre, sulle descrizioni dei tre target: le uniche informazioni disponibili per prendere la decisione.

Punti chiave

  • Nessun limite di profondità per la catena di agenti
  • Tre schemi: lineare (A→B→C), a stella (router→specialisti), ibrido (grafo)
  • Ogni agente può avere più target di passaggio
  • In produzione, limita le catene a 2–4 agenti per controllare latenza e costi
  • Le descrizioni degli agenti sono cruciali per un routing efficace