Tutorial AutoGen: crea applicazioni di IA multi-agent

L’IA moderna è iniziata con i Large Language Model (LLM), poi con il function calling per l’output strutturato, quindi con lo sviluppo di agenti e tool, fino alla creazione dei server MCP. Oggi l’attenzione è sui sistemi multi-agent. Le aziende cercano soluzioni per costruire sistemi intelligenti automatizzati usando vari strumenti, con AutoGen come il più popolare tra questi.

In questo tutorial esploreremo AutoGen, il suo ecosistema, i vari casi d’uso e come utilizzare ciascun componente al suo interno. È importante notare che AutoGen non è un semplice strumento di orchestrazione di modelli linguistici come LangChain; offre molto di più.

Se sei alle prime armi con l’IA, segui prima il percorso di competenze Fondamenti di IA prima di proseguire con questo tutorial. Puoi anche approfondire l’Agentic AI in un articolo separato. 

Che cos’è AutoGen?

AutoGen è un framework open source progettato per creare applicazioni di IA multi-agent che possono operare in modo semi-autonomo e completamente autonomo. Fornisce agli sviluppatori gli strumenti per costruire sistemi in cui più agenti di IA possono comunicare, cooperare ed eseguire attività insieme.

AutoGen supporta un’ampia gamma di casi d’uso, tra cui workflow automatizzati, collaborazione multi-agent e risoluzione dinamica dei task. Consente di creare sistemi in cui gli agenti interagiscono in linguaggio naturale, eseguono codice, recuperano informazioni e si adattano a workflow complessi.

L’ecosistema AutoGen è suddiviso in quattro componenti principali:

1. AutoGen Studio: un’interfaccia grafica no-code per creare e testare workflow multi-agent.
2. AutoGent AgentChat: un’API semplificata per creare applicazioni conversazionali a singolo agente e multi-agent.
3. AutoGen Core: l’API di base per costruire sistemi di IA multi-agent scalabili. 
4. AutoGen Extension: una libreria di estensioni first- e third-party che ampliano le capacità del framework.

Fonte: microsoft/AutoGen

AutoGen si distingue per la capacità di:

• Semplificare l’orchestrazione e l’ottimizzazione di workflow LLM complessi.
• Migliorare le prestazioni degli LLM affrontandone i limiti.
• Abilitare la creazione fluida di sistemi multi-agent che integrano LLM, strumenti e input umani.

La sua estensibilità e modularità lo rendono uno strumento potente per sviluppatori in molti settori, dalla finanza e sanità all’istruzione e alla robotica.

Leggi Understanding AI Agents: The Future of Autonomous Systems per scoprire come sfruttare gli agenti di IA per innovazione ed efficienza nei tuoi progetti.

Primi passi con l’ecosistema AutoGen

In questa sezione esploreremo i quattro componenti principali dell’ecosistema AutoGen installandoli ed eseguendoli in locale.

1. AutoGen Studio

AutoGen Studio è un’interfaccia low-code pensata per aiutarti a prototipare rapidamente agenti di IA. Offre un’interfaccia intuitiva drag-and-drop per creare sistemi multi-agent e testarli in tempo reale.

1. Per installare lo Studio, usa il comando pip.

pip install -U AutoGenstudio

2. Una volta installato, puoi avviare l’interfaccia di AutoGen Studio specificando la porta e la directory dell’applicazione in cui verranno salvati tutti gli agenti e i template. 

AutoGenstudio ui --port 8080 --appdir ./app

Dopo aver eseguito il comando, nel terminale dovresti vedere il seguente output:

INFO  [alembic.runtime.migration] Context impl SQLiteImpl.
INFO  [alembic.runtime.migration] Will assume non-transactional DDL.
2025-05-09 15:15:22.825 | INFO     | AutoGenstudio.web.app:lifespan:39 - Application startup complete. Navigate to http://127.0.0.1:8080

3. Vai su http://127.0.0.1:8080 nel browser per accedere alla dashboard di AutoGen Studio.

Quando l’applicazione è in esecuzione, verrai accolto da un’interfaccia pulita e intuitiva.

AutoGen Studio offre diverse funzionalità chiave per aiutarti a creare e gestire workflow multi-agent:

1. Team Builder: un’interfaccia drag-and-drop per creare team di agenti.
2. Playground: un ambiente interattivo per testare ed eseguire i workflow degli agenti.
3. Gallery: un hub centrale per scoprire e importare componenti creati dalla community.
4. Labs: una funzionalità sperimentale di AutoGen Studio che consente di esplorare workflow avanzati e prototipare idee all’avanguardia.
5. Deploy: esporta ed esegui i workflow degli agenti come codice Python.

AutoGen Studio è un’applicazione low-code, il che significa che ti permette di creare workflow con poco codice. Allo stesso tempo, offre la flessibilità di personalizzare agenti e workflow usando codice Python.

2. AutoGen AgentChat

AgentChat è un framework di alto livello per creare workflow conversazionali multi-agent. Semplifica la creazione di applicazioni in cui più agenti (IA, tool o persone) collaborano per risolvere task. 

Per prima cosa, installa i pacchetti richiesti:

pip install -U "AutoGen-agentchat" "AutoGen-ext[openai]"

Imposteremo quindi tre agenti — un utente, un coder e un esecutore di codice — che collaborano in una chat di gruppo a giro (round-robin) per generare, eseguire e raccontare codice Python. Il sistema è progettato per facilitare la generazione ed esecuzione dinamica di codice, consentendo al contempo l’interazione umana e condizioni di terminazione.

Per questo esempio usiamo il modello gpt-4.1-mini per la generazione di codice, CodeExecutorAgent per l’esecuzione del codice da riga di comando e UserProxyAgent per mantenere l’umano nel ciclo. 

import asyncio
from pathlib import Path

from AutoGen_agentchat.agents import AssistantAgent, CodeExecutorAgent, UserProxyAgent
from AutoGen_agentchat.conditions import TextMentionTermination
from AutoGen_agentchat.teams import RoundRobinGroupChat
from AutoGen_agentchat.ui import Console
from AutoGen_ext.code_executors.local import LocalCommandLineCodeExecutor
from AutoGen_ext.models.openai import OpenAIChatCompletionClient

async def main() -> None:
    model_client = OpenAIChatCompletionClient(model="gpt-4.1-mini")

    coder = AssistantAgent(
        "coder",
        model_client=model_client,
        system_message=(
            "You are a senior engineer. Think step-by-step, then output ONLY runnable "
            "Python inside ```pythonthon``` blocks—no commentary."
        ),
    )

    executor = CodeExecutorAgent(
        "executor",
        model_client=model_client,  # lets it narrate results
        code_executor=LocalCommandLineCodeExecutor(work_dir=Path.cwd() / "runs"),
    )

    user = UserProxyAgent("user")  # human in the loop

    termination = TextMentionTermination("exit", sources=["user"])
    team = RoundRobinGroupChat(
        [user, coder, executor], termination_condition=termination
    )

    try:
        await Console(
            team.run_stream()
        )
    finally:
        await model_client.close()

if __name__ == "__main__":
    asyncio.run(main())

Salva il codice sopra in un file chat_app.py ed eseguilo con:

python chat_app.py 

Abbiamo chiesto all’applicazione di agenti di generare il codice per stampare le stelle in forma di triangolo e poi di eseguirlo. 

Ha generato ed eseguito il codice correttamente, offrendo anche opzioni aggiuntive. L’utente può digitare “exit” per uscire o porre domande di follow-up per un’esperienza conversazionale.

Output: 

Enter your response: Write a Python script that prints stars and run it.
---------- TextMessage (user) ----------
Write a Python script that prints stars and run it.

---------- TextMessage (coder) ----------
# Print a simple star pattern
for i in range(1, 6):
    print('*' * i)

---------- CodeGenerationEvent (executor) ----------
# Print a simple star pattern
for i in range(1, 6):
    print('*' * i)

---------- CodeExecutionEvent (executor) ----------

*

**

***

****

*****

---------- TextMessage (executor) ----------

The star pattern has been printed successfully. If you'd like a different pattern or further modifications, just let me know!

Enter your response:

3. AutoGen Core

AutoGen Core è un framework di basso livello che offre un modo potente per creare e gestire sistemi multi-agent. 

In questo esempio creeremo due agenti: un Echo Agent che inverte il contenuto di un messaggio e un Printer Agent che stampa il contenuto del messaggio in console.

pip install "autogen-core"

Componenti usati in questa applicazione:

1. Struttura del messaggio: la classe Text è una semplice struttura dati che contiene il contenuto di un messaggio.

2. Echo Agent: l’agente Echo inverte il contenuto di ogni messaggio ricevuto e pubblica il messaggio invertito sul topic predefinito usando publish_message.

3. Printer Agent: l’agente Printer ascolta i messaggi e ne stampa il contenuto in console.

4. Runtime: SingleThreadedAgentRuntime viene usato per gestire il ciclo di vita degli agenti e instradare i messaggi.

import asyncio
from dataclasses import dataclass

from AutoGen_core import (
    AgentId,
    DefaultTopicId,
    MessageContext,
    RoutedAgent,
    SingleThreadedAgentRuntime,
    default_subscription,
    message_handler,
)

@dataclass
class Text:
    content: str

@default_subscription
class Echo(RoutedAgent):
    def __init__(self) -> None:
        super().__init__("echo")

    @message_handler
    async def handle(self, message: Text, ctx: MessageContext) -> None:  # param must be named 'message'
        await self.publish_message(Text(message.content[::-1]), DefaultTopicId())

@default_subscription
class Printer(RoutedAgent):
    def __init__(self) -> None:
        super().__init__("printer")

    @message_handler
    async def handle(self, message: Text, ctx: MessageContext) -> None:  # param must be named 'message'
        print(message.content)

async def main() -> None:
    rt = SingleThreadedAgentRuntime()
    await Echo.register(rt, "echo", lambda: Echo())
    await Printer.register(rt, "printer", lambda: Printer())
    rt.start()
    await rt.send_message(Text("DataCamp"), AgentId("echo", "default"))
    await rt.stop_when_idle()

if __name__ == "__main__":
    asyncio.run(main())

Salva il codice in un file core_app.py ed eseguilo con:

python core_app.py            

Flusso dei messaggi:

• Un messaggio con contenuto "DataCamp" viene inviato all’agente Echo.
• L’agente Echo inverte il messaggio in "pmaCataD" e lo pubblica.
• L’agente Printer riceve il messaggio invertito e lo stampa in console.

Output: 

pmaCataD

4. AutoGen Extensions

Il framework AutoGen Extensions fornisce estensioni first- e third-party che ampliano le funzionalità del framework. 

In questo esempio mostreremo come usare l’agente MultimodalWebSurfer, che può interagire con pagine web, effettuare ricerche ed estrarre informazioni. 

Prima di eseguire l’esempio, assicurati di aver installato Playwright:

playwright install 

Come funziona il codice: 

1. Inizializzazione dell’agente: viene creato un agente MultimodalWebSurfer che usa il modello gpt-4.1-mini di OpenAI per il decision-making e un browser (via Playwright) per le interazioni web.
2. Configurazione del team: l’agente viene aggiunto a un team RoundRobinGroupChat, che gestisce il workflow dell’agente e limita il task a 3 turni.
3. Esecuzione del task: al team viene assegnato il compito: "Navigate to Google and search about Abid Ali Awan." L’agente apre un browser, naviga su Google, effettua la ricerca ed estrae le informazioni rilevanti.
4. Output in streaming: le azioni dell’agente (ad esempio navigazione, clic sui link, estrazione dei metadati) vengono mostrate in tempo reale in console.
5. Pulizia: al termine del task, il browser viene chiuso per liberare risorse.

import asyncio
from AutoGen_agentchat.ui import Console
from AutoGen_agentchat.teams import RoundRobinGroupChat
from AutoGen_ext.models.openai import OpenAIChatCompletionClient
from AutoGen_ext.agents.web_surfer import MultimodalWebSurfer

async def main() -> None:
    # Define an agent
    web_surfer_agent = MultimodalWebSurfer(
        name="MultimodalWebSurfer",
        model_client=OpenAIChatCompletionClient(model="gpt-4.1-mini"),
    )

    # Define a team
    agent_team = RoundRobinGroupChat([web_surfer_agent], max_turns=3)

    # Run the team and stream messages to the console
    stream = agent_team.run_stream(task="Navigate to Google and search about Abid Ali Awan.")
    await Console(stream)
    # Close the browser controlled by the agent
    await web_surfer_agent.close()

asyncio.run(main())

Salva il codice in un file, web_ext_app.py, ed eseguilo con:

python web_ext_app.py          

Quando avvii l’applicazione, si verificherà la seguente interazione:

                                                           
---------- TextMessage (user) ----------
Navigate to Google and search about Abid Ali Awan.
---------- MultiModalMessage (MultimodalWebSurfer) ----------
I typed 'https://www.google.com' into the browser address bar.

The web browser is open to the page [Google](https://www.google.com/).
The viewport shows 100% of the webpage, and is positioned at the top of the page
The following text is visible in the viewport:

Gmail
Images
Sign in
Google offered in:
اردو
پښتو
سنڌيPakistan
About
Advertising
Business
 How Search works
Privacy
Terms
Settings
Google recommends using Chrome
Try a fast, secure browser with updates built in
Don't switch
Yes

The following metadata was extracted from the webpage:

{
    "microdata": [
        {
            "itemType": "http://schema.org/WebPage",
            "image": "/images/branding/googleg/1x/googleg_standard_color_128dp.png"
        }
    ],
    "meta_tags": {
        "referrer": "origin"
    }
}

Here is a screenshot of the page.
<image>
---------- MultiModalMessage (MultimodalWebSurfer) ----------
I clicked 'Sign in'.

The web browser is open to the page [Sign in - Google Accounts](https://accounts.google.com/v3/signin/identifier?continue=https%3A%2F%2Fwww.google.com%2F&ec=futura_exp_og_so_72776762_e&hl=en&ifkv=ASKV5MhAzFZnwDH-Aw10tuqQN1ppsY8OZ2-OJ3YavFHXMDlX9iTddg1d_k78ZZ0SogFUivcY7Td0Hg&passive=true&flowName=GlifWebSignIn&flowEntry=ServiceLogin&dsh=S1980923188%3A1746809726624486).
The viewport shows 100% of the webpage, and is positioned at the top of the page
The following text is visible in the viewport:

Sign inUse your Google AccountEmail or phone
Forgot email?
Not your computer? Use a private browsing window to sign in.
Learn more about using Guest modeNext
Create account
English (United States)
Help
Privacy
Terms
Sign in Use your Google Account

The following metadata was extracted from the webpage:

{
    "meta_tags": {
        "referrer": "origin",
        "chrome": "nointentdetection",
        "viewport": "width=device-width, initial-scale=1",
        "description": ""
    }
}

Here is a screenshot of the page.
<image>
---------- TextMessage (MultimodalWebSurfer) ----------
Please provide the email or phone number you want to use to sign in, or let me know if you want to create a new account or need help with something else on this page.

Simile ad AutoGen, CrewAI è un altro framework molto apprezzato per costruire workflow agentic. Segui il tutorial CrewAI: una guida con esempi di sistemi multi‑agente IA per saperne di più.

Casi d’uso di AutoGen

AutoGen apre numerose possibilità per creare sistemi intelligenti multi-agent. Ecco alcuni dei casi d’uso più rilevanti dell’ecosistema AutoGen:

1. Generazione, esecuzione e debug del codice: automatizza i compiti di coding, riducendo gli errori e migliorando l’efficienza.
2. Collaborazione multi-agent: abilita il lavoro di squadra tra agenti per risolvere compiti complessi.
3. Chat multi-agent sequenziali: gestiscono sequenze strutturate di task per un completamento efficiente.
4. Chat annidate: gestiscono compiti intricati tramite conversazioni dettagliate e a livelli.
5. Uso di tool: amplia le funzionalità degli agenti integrando strumenti come web search e query SQL.
6. Coinvolgimento umano: incorpora feedback umani per migliorare i workflow.
7. Insegnamento e apprendimento degli agenti: potenzia le competenze e la conoscenza degli agenti.
8. Chat multi-agent con OpenAI Assistants: combina le capacità di OpenAI con AutoGen per task avanzati.
9. Agente multimodale: gestisce testo, immagini e altri media per interazioni più ricche.
10. Gestione di contesti lunghi: mantiene la coerenza in conversazioni estese.

Conclusione

Non è un caso se AutoGen ha attirato così tanta attenzione e riconoscimento, guadagnandosi il posto tra i framework agentic con più stelle su GitHub. 

È un framework completo che si rivolge a tutti: dagli sviluppatori professionisti ai programmatori occasionali, fino a chi non ha esperienza di coding. 

Con AutoGen puoi prototipare rapidamente i workflow con AutoGen Studio, costruire applicazioni robuste con il Core e le Extensions e distribuirle senza soluzione di continuità sul cloud. È davvero una soluzione all‑in‑one per creare e gestire sistemi intelligenti multi-agent.

Segui il corso Build Dynamic LangChain Agents e impara a creare la tua prima applicazione di agenti IA con il popolare framework LLM.