Guida ad AutoGPT: creare e distribuire agenti IA autonomi in locale

La piattaforma AutoGPT è una piattaforma che consente agli utenti di creare, distribuire e gestire agenti IA continui. Utilizza una UI low-code per permettere di automatizzare migliaia di processi digitali, con agenti che operano in autonomia dietro le quinte.

La piattaforma AutoGPT ha due componenti principali: l’AutoGPT Server, la logica e l’infrastruttura principali, e l’AutoGPT Frontend, l’interfaccia per costruire gli agenti, gestire i workflow e impostare pianificazioni ricorrenti. 

È preintegrata con provider di LLM come OpenAI, Anthropic, Groq e Llama, così da poter automatizzare un’ampia gamma di attività come l’elaborazione dati, la creazione di contenuti o anche attività ludiche. 

In questo tutorial, guideremo i professionisti tecnici nella configurazione locale della piattaforma AutoGPT e nella creazione del loro primo agente. Puoi leggere la nostra guida completa su Capire gli agenti IA per saperne di più, e scoprire anche i diversi tipi di agenti IA in un articolo dedicato. 

Che cos’è AutoGPT?

AutoGPT è una piattaforma/software di IA che consente di creare, distribuire e gestire agenti IA autonomi. Questi agenti possono svolgere varie attività con minima supervisione umana tramite un’interfaccia low-code installata sulla macchina dell’utente. 

Al momento della stesura, c’è una lista d’attesa aperta per una prossima versione cloud di AutoGPT se vuoi evitare la complessità della configurazione locale.

Funzionalità e capacità chiave di AutGPT includono:

• Workflow low-code: crea flussi di lavoro senza conoscenze di coding approfondite.
• Operatività autonoma: distribuisci agenti che girano in continuo, attivandosi su trigger specifici.
• Automazione intelligente: automatizza processi ripetitivi per elaborazione dati, creazione di contenuti e altre attività.
• Sistema a blocchi: costruisci agenti usando blocchi modulari che rappresentano diverse azioni e integrazioni.
• Supporto multi-LLM: compatibile con OpenAI, Anthropic, Groq e Llama.
• Marketplace: accedi ad agenti preconfigurati per casi d’uso specifici.

Panoramica dell’architettura di AutoGPT

La piattaforma AutoGPT è composta da due componenti principali:

1. AutoGPT server:

• Logica core per agenti e automazione
• Infrastruttura per prestazioni affidabili
• Marketplace per agenti predefiniti

2. AutoGPT frontend:

• Builder di agenti per progettare e configurare gli agenti
• Strumenti di gestione dei workflow
• Controlli di deployment
• Selezione di agenti pronti all’uso
• Dashboard di monitoraggio e analitiche

Il backend di AutoGPT usa Python con FastAPI come framework web e PostgreSQL con Prisma ORM per l’archiviazione dei dati. Utilizza websocket per la comunicazione in tempo reale e include manager per esecuzione, pianificazione e notifiche. 

Questo design migliora scalabilità e manutenzione con la crescita della piattaforma.

Il frontend usa Next.js 14 con TypeScript, componenti Radix e Tailwind CSS, con visualizzazione dei workflow tramite xyflow. Ne risulta un’interfaccia low-code intuitiva in cui è possibile costruire agenti IA senza conoscenze di programmazione approfondite.

La piattaforma include questi servizi chiave:

• Database manager: archivia configurazioni degli agenti e dati di esecuzione
• Execution manager: esegue i workflow e gestisce lo stato degli agenti
• Scheduler: gestisce automazioni basate sul tempo e attività ricorrenti
• Server WebSocket: fornisce aggiornamenti in tempo reale
• REST API: offre accesso programmatico alle funzionalità
• Protocollo agenti: standardizza la comunicazione con servizi esterni
• API di integrazione: connette a servizi di terze parti e provider IA

AutoGPT nel 2025 vs versioni precedenti

Quando è stato annunciato per la prima volta intorno al 2023, AutoGPT è esploso in popolarità ed è stato visto come il killer open-source di ChatGPT. Ovviamente, era solo hype trainato dai social influencer, perché siamo nel 2025 e ChatGPT è ancora qui. Ma AutoGPT ha segnalato il cambio di focus della community IA verso gli agenti.

Le prime versioni di AutoGPT promettevano agenti completamente autonomi costruibili al volo da un singolo prompt. Sarebbe stato in grado di scomporre il prompt in attività gestibili e mettere insieme una varietà di strumenti, software e API per portare a termine il lavoro, il tutto avendo memoria a breve e lungo termine potenziata da un loop di auto-riflessione. 

Tuttavia, lungo il percorso devono aver realizzato i limiti di questo approccio a causa dell’intrinseca imprevedibilità dei LLM in scenari di produzione.

Oggi, AutoGPT non è più quella piattaforma “prompt-to-agent”, ma qualcosa di molto migliore: una piattaforma low-code che mette gli utenti al controllo di come vengono costruiti i loro agenti. Puoi vedere questo cambio dall’AutoGPT originale alla piattaforma che abbiamo nel 2025 se leggi i post di 1–2 anni fa o guardi video su YouTube. 

Quei post mostrano istruzioni di setup e esempi di workflow completamente diversi da ciò che sto per insegnarti.

Quindi, senza ulteriori indugi, vediamo come puoi configurare la piattaforma sulla tua macchina.

Installazione e configurazione di AutoGPT

Configurare AutoGPT in locale richiede una corretta impostazione dell’ambiente di sviluppo e la comprensione degli strumenti di containerizzazione: dai un’occhiata al nostro corso su Containerizzazione e virtualizzazione con Docker e Kubernetes se ti serve un ripasso. Questa sezione ti guida nell’intero processo, dai prerequisiti all’esecuzione della piattaforma per la prima volta.

Prerequisiti e setup dell’ambiente

Prima di installare AutoGPT, assicurati di avere i seguenti prerequisiti:

1. Node.js & NPM

• Mac:
• brew install node
• Linux/WSL2:
• sudo apt update sudo apt install nodejs npm
• Verifica l’installazione:
• node -v npm -v

2. Docker & Docker Compose

• Mac: Scarica e installa Docker Desktop
• Linux (WSL2 include già il kernel Docker e richiede l’installazione):
• sudo apt update sudo apt install docker.io docker-compose sudo systemctl enable --now docker
• Verifica l’installazione:
• docker -v docker compose -v

3. Git

• Mac:
• brew install git
• Linux/WSL2:
• sudo apt update sudo apt install git

Clona il repository AutoGPT:

git clone https://github.com/Significant-Gravitas/AutoGPT.gitOfferto da

Questi prerequisiti sono essenziali per eseguire AutoGPT in modo efficace. Node.js e NPM sono necessari per l’applicazione frontend, consentendoti di interagire con AutoGPT tramite un’interfaccia user-friendly. 

Docker e Docker Compose creano container isolati che garantiscono prestazioni coerenti tra diversi sistemi e semplificano il deployment dei servizi backend. Git ti permette di clonare il repository e restare aggiornato con gli ultimi miglioramenti.

Dopo questo passaggio, dovresti avere la directory AutoGPT sulla tua macchina, che contiene tutto il necessario per eseguire l’applicazione. Resta solo la configurazione.

Hosting locale con Docker 

Docker fornisce un ambiente isolato e coerente per l’esecuzione di AutoGPT, assicurando che tutte le dipendenze funzionino correttamente a prescindere dal sistema host.

1. Configura i servizi backend

cd AutoGPT/autogpt_platform
cp .env.example .env
docker compose up -d --buildOfferto da

Il nuovo file .env viene fornito con variabili d’ambiente impostate su valori predefiniti sensati. Non sei strettamente tenuto a configurare questo file manualmente, ma la sua presenza è indispensabile. Verrà utilizzato dall’applicazione frontend quando fornirai varie chiavi e secret durante la creazione dei tuoi agenti personalizzati.

L’ultimo comando docker compose può richiedere fino a 15 minuti al primo avvio a seconda della velocità di Internet. Configura i componenti backend a cui si connetterà il frontend.

2. Configura l’applicazione frontend

cd frontend
cp .env.example .env
npm install
npm run devOfferto da

Questi comandi impostano il file di ambiente per il frontend, installano le sue dipendenze con Node.js e avviano la UI.

3. Verifica l’installazione

• Accedi alla UI di AutoGPT su http://localhost:3000
• I servizi backend girano sulle porte:
• WebSocket Server: 8001
• Execution API: 8006

Visitando la porta 3000 dovresti vedere la UI del Marketplace, tramite cui creare il tuo account e accedere.

4. Personalizza la tua chiave di cifratura (opzionale ma consigliato)

# Genera una nuova chiave con Python
from cryptography.fernet import Fernet
Fernet.generate_key().decode()

# Oppure usa la CLI integrata
poetry run cli gen-encrypt-keyOfferto da

Sostituisci la chiave esistente in autogpt_platform/backend/.env con la tua nuova chiave.

Nota per utenti Windows: quando usi Docker su Windows, seleziona WSL 2 invece di Hyper-V durante l’installazione per evitare problemi di compatibilità con Supabase. Se hai già installato con Hyper-V, puoi passare a WSL 2 dalle impostazioni di Docker Desktop.

Panoramica dell’interfaccia utente di AutoGPT

Prima di creare un agente funzionante, familiarizziamo con l’interfaccia del builder di AutGPT.

L’interfaccia è una grande tela vuota con quattro pulsanti principali:

• Blocks
• Pulsanti annulla/ripristina
• Salva

Cliccando su “Blocks” compare un menu con i componenti riutilizzabili integrati di AutoGPT, raggruppati per categorie.

Questi blocchi forniscono strumenti essenziali applicabili in modo trasversale a molti scenari d’agente. 

Ad esempio, qui sotto ho cercato e aggiunto due blocchi — input testo lungo e generatore di testo IA. Questi due componenti sono sufficienti per ricreare la versione base dell’interfaccia di ChatGPT:

Osservando l’immagine, puoi vedere che ogni blocco ha elementi diversi. Il blocco di input ha campi per il nome del blocco e un valore predefinito, mentre il generatore di testo ha un campo per il prompt, il modello e le variabili del prompt. 

Quest’ultimo ha anche un campo di input una tantum per la tua API key di OpenAI, che devi fornire prima di eseguire l’agente (fallo ora). Il campo della API key cambia in base al modello scelto e AutoGPT supporta la maggior parte dei provider principali e minori.

Se ci fai caso, entrambi i blocchi hanno dei piccoli spigoli (guarda 3 e 5) che ti permettono di collegarli:

Nell’immagine sopra, sto dando al blocco di input un nome (1) e un valore predefinito (2), e collegando il suo risultato testuale (3) al campo prompt (4) del generatore di testo. Questa connessione crea un workflow di agente di base, che può essere eseguito dopo aver salvato l’agente stesso (passi 5–8).

Dopo aver cliccato su run, vedrai comparire un menu “Run settings” per il campo di input:

Scrivi il tuo prompt ed esegui il tutto per ottenere il primo output come sotto:

Potresti notare che la risposta del modello è difficilmente leggibile all’interno del blocco di generazione testo più grande. Per questo AutoGPT ha blocchi per gli output dell’agente, che sto aggiungendo qui sotto:

Nota come ho collegato il campo response del generatore di testo al value del blocco di output dell’agente. Aggiungere un blocco di output ti consente anche di visualizzare tutti gli output dell’agente provenienti da diversi blocchi in un unico posto tramite il pannello “Agent Outputs”:

Una volta salvato, il tuo agente verrà archiviato nella tua libreria. Inoltre, l’intero agente può poi essere usato come blocco in altri agenti che crei. Questo approccio modulare offre diversi vantaggi:

1. Riutilizzabilità: puoi riutilizzare funzionalità complesse in più progetti senza ricostruirle.
2. Componibilità: puoi combinare agenti diversi per creare workflow più sofisticati.
3. Manutenibilità: quando aggiorni l’agente originale, tutte le istanze che lo usano come blocco beneficeranno dei miglioramenti.
4. Astrazione: i processi complessi possono essere incapsulati in un singolo blocco, rendendo i workflow principali più puliti e facili da capire.
5. Collaborazione: puoi condividere blocchi di agenti specializzati con i compagni di squadra o la community, accelerando lo sviluppo.

Questo approccio a blocchi ti permette di creare sistemi IA sempre più potenti sovrapponendo capacità una sull’altra.

Scrivere blocchi personalizzati in AutoGPT in Python

Panoramica della sintassi e del processo generale

La potenza di AutoGPT deriva dal suo sistema modulare a blocchi. Sebbene la piattaforma includa molti blocchi integrati utili, puoi estenderne le capacità creando i tuoi blocchi personalizzati in Python. Questa funzionalità ti consente di integrare qualsiasi API, servizio o strumento accessibile in modo programmatico.

Creare un blocco personalizzato prevede questi passaggi essenziali:

1. Crea un nuovo file Python nella directory autogpt_platform/backend/backend/blocks usando una denominazione snake_case
2. Definisci una classe che eredita dalla classe base Block
3. Crea gli schemi di input e output usando BlockSchema per definire la struttura dei dati
4. Implementa il metodo __init__ con un ID univoco e dati di test
5. Scrivi il metodo run contenente la logica core del blocco
6. Gestisci correttamente gli errori per assicurare che il blocco fallisca in modo controllato
7. Testa il tuo blocco usando l’infrastruttura di test della piattaforma

Analizziamo ogni componente nel dettaglio:

Struttura della classe Block

Ogni blocco deve ereditare dalla classe base Block e definire i suoi schemi di input/output:

from backend.data.block import Block, BlockSchema, BlockOutput

class MyCustomBlock(Block):
   class Input(BlockSchema):
       # Define input fields with types
       field1: str
       field2: int
      
   class Output(BlockSchema):
       # Define output fields with types
       result: str
       error: str  # Always include an error field
      
   def __init__(self):
       super().__init__(
           id="xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",  # Generate proper UUID
           input_schema=MyCustomBlock.Input,
           output_schema=MyCustomBlock.Output,
           test_input={"field1": "test", "field2": 42},
           test_output=("result", "expected output"),
           test_mock=None  # Only needed for external API calls
       )
      
   def run(self, input_data: Input, **kwargs) -> BlockOutput:
       try:
           # Your block logic here
           result = f"Processed {input_data.field1} and {input_data.field2}"
           yield "result", result
       except Exception as e:
           raise RuntimeError(f"Error in block: {str(e)}")Offerto da

Componenti importanti

1. Schemi di input/output: definiscono la struttura dei dati usando type hint
2. Generazione UUID: usa un generatore UUID appropriato (non inventarne uno)
3. Dati di test: fornisci input di test realistici e output attesi
4. Gestione errori: includi sempre una corretta gestione degli errori nel metodo run
5. Yield dei risultati: usa yield per emettere i risultati uno alla volta

Un esempio di blocco personalizzato

Creiamo un esempio dettagliato di blocco personalizzato che esegue un’analisi del sentiment usando l’API di OpenAI. Questo dimostra come integrare servizi IA esterni e gestire in modo sicuro le API key.

Istruzioni di setup per la API key di OpenAI

Prima di usare questo blocco, devi configurare la tua API key di OpenAI:

1. Installa i pacchetti richiesti:

• pip install openai python-dotenv

2. Crea un file .env nella directory autogpt_platform/backend/blocks con la tua API key di OpenAI:

• OPENAI_API_KEY=your_api_key_here

Ora creiamo il blocco:

Importa le dipendenze e imposta l’ambiente

Per prima cosa, occupiamoci degli import e del setup dell’ambiente:

# autogpt_platform/backend/blocks/sentiment_analyzer.py
from backend.data.block import Block, BlockSchema, BlockOutput
from typing import Dict, Any, List
import os
from dotenv import load_dotenv
from openai import OpenAI
import json

# Load environment variables from .env file
load_dotenv()Offerto da

Questa sezione importa le librerie necessarie e carica le variabili d’ambiente dal file .env. La funzione load_dotenv() assicura che la tua API key sia disponibile tramite os.getenv().

Definisci lo schema del blocco e inizializza

Successivamente, definiamo la classe del blocco con gli schemi di input e output:

class OpenAISentimentBlock(Block):
   """Block to analyze sentiment of text using OpenAI API"""
  
   class Input(BlockSchema):
       text: str  # Text to analyze
       model: str = "gpt-3.5-turbo"  # OpenAI model to use
       detailed_analysis: bool = False  # Whether to return detailed analysis
      
   class Output(BlockSchema):
       sentiment: str  # Positive, Negative, or Neutral
       confidence: float  # Confidence score of the prediction
       explanation: str  # Brief explanation of the sentiment
       detailed_analysis: Dict[str, Any]  # Optional detailed analysis
       error: str  # Error message if analysis failsOfferto da

Lo schema di input definisce tre parametri:

• text: il contenuto da analizzare (obbligatorio)
• model: il modello OpenAI da usare (predefinito "gpt-3.5-turbo")
• detailed_analysis: se restituire dettagli aggiuntivi (predefinito False)

Lo schema di output definisce la struttura dei risultati, inclusi la categoria di sentiment, lo score di confidenza, la spiegazione e l’analisi dettagliata opzionale.

Inizializza il blocco con dati di test

Il metodo __init__ configura il blocco con dati di test e inizializza il client OpenAI:

def __init__(self):
   super().__init__(
       id="8f67d394-9f52-4352-a78b-175d5d1d7182",  # Generated UUID
       input_schema=OpenAISentimentBlock.Input,
       output_schema=OpenAISentimentBlock.Output,
       test_input={
           "text": "I really enjoyed this product, it exceeded my expectations!",
           "detailed_analysis": True
       },
       test_output=[
           ("sentiment", str),
           ("confidence", float),
           ("explanation", str),
           ("detailed_analysis", dict)
       ],
       test_mock={
           "_analyze_sentiment": lambda text, model, detailed: {
               "sentiment": "positive",
               "confidence": 0.92,
               "explanation": "The text expresses clear enjoyment and states that expectations were exceeded.",
               "detailed_analysis": {
                   "emotions": {
                       "joy": "high",
                       "satisfaction": "high",
                       "disappointment": "none"
                   },
                   "key_phrases": ["really enjoyed", "exceeded expectations"],
                   "tone": "enthusiastic"
               }
           }
       }
   )
   # Initialize OpenAI client
   api_key = os.getenv("OPENAI_API_KEY")
   if not api_key:
       raise RuntimeError("OpenAI API key not found. Please set OPENAI_API_KEY in .env file.")
   self.client = OpenAI(api_key=api_key)Offerto da

Questo metodo:

• Configura input di test realistici e output attesi per i test
• Fornisce un mock per la funzione di analisi del sentiment per evitare chiamate API durante i test
• Inizializza il client OpenAI con la API key dalle variabili d’ambiente
• Genera un errore se manca la API key

Implementa il metodo di analisi del sentiment

La funzionalità core è implementata nel metodo _analyze_sentiment:

@staticmethod
def _analyze_sentiment(self, text: str, model: str, detailed: bool) -> Dict[str, Any]:
   """Analyze sentiment using OpenAI API"""
   # Create prompt based on whether detailed analysis is requested
   if detailed:
       system_prompt = """
       You are a sentiment analysis expert. Analyze the following text and provide:
       1. The overall sentiment (positive, negative, or neutral)
       2. A confidence score from 0.0 to 1.0
       3. A brief explanation of your assessment
       4. A detailed analysis including:
          - Key emotions detected and their intensity
          - Key phrases that influenced your assessment
          - Overall tone of the text
      
       Format your response as a JSON object with the following structure:
       {
           "sentiment": "positive|negative|neutral",
           "confidence": 0.0-1.0,
           "explanation": "brief explanation",
           "detailed_analysis": {
               "emotions": {"emotion1": "intensity", "emotion2": "intensity"},
               "key_phrases": ["phrase1", "phrase2"],
               "tone": "description of tone"
           }
       }
       """
   else:
       system_prompt = """
       You are a sentiment analysis expert. Analyze the following text and provide:
       1. The overall sentiment (positive, negative, or neutral)
       2. A confidence score from 0.0 to 1.0
       3. A brief explanation of your assessment
      
       Format your response as a JSON object with the following structure:
       {
           "sentiment": "positive|negative|neutral",
           "confidence": 0.0-1.0,
           "explanation": "brief explanation"
       }
       """
  
   try:
       # Make API call using the latest OpenAI API syntax
       response = self.client.chat.completions.create(
           model=model,
           response_format={"type": "json_object"},
           messages=[
               {"role": "system", "content": system_prompt},
               {"role": "user", "content": text}
           ],
           temperature=0.2  # Low temperature for more consistent results
       )
      
       # Extract and parse JSON response
       content = response.choices[0].message.content
       result = json.loads(content)
      
       return result
      
   except Exception as e:
       raise RuntimeError(f"OpenAI API error: {str(e)}")Offerto da

Questo metodo:

• Crea un system prompt diverso a seconda che venga richiesta l’analisi dettagliata
• Usa l’API di OpenAI per generare un’analisi del sentiment strutturata
• Imposta una temperatura bassa (0,2) per risultati più coerenti
• Analizza la risposta JSON e la restituisce
• Gestisce le eccezioni che possono verificarsi durante la chiamata API

Implementa il metodo run

Infine, il metodo run mette insieme il tutto:

def run(self, input_data: Input, **kwargs) -> BlockOutput:
   try:
       # Validate input
       if not input_data.text or not isinstance(input_data.text, str):
           raise ValueError("Text must be a non-empty string")
      
       # Process through OpenAI
       results = self._analyze_sentiment(
           input_data.text,
           input_data.model,
           input_data.detailed_analysis
       )
      
       # Yield the results
       yield "sentiment", results["sentiment"]
       yield "confidence", results["confidence"]
       yield "explanation", results["explanation"]
      
       # Only return detailed analysis if requested and available
       if input_data.detailed_analysis and "detailed_analysis" in results:
           yield "detailed_analysis", results["detailed_analysis"]
      
   except ValueError as e:
       raise RuntimeError(f"Input validation error: {str(e)}")
   except Exception as e:
       raise RuntimeError(f"Sentiment analysis failed: {str(e)}")Offerto da

Questo metodo:

• Convalida il testo di input
• Chiama il metodo di analisi del sentiment con i parametri di input
• Emette i risultati uno alla volta usando la keyword yield
• Emette l’analisi dettagliata solo se richiesta e disponibile
• Gestisce diversi tipi di errori con messaggi appropriati

Aspetti chiave di questo esempio

1. Integrazione con l’API OpenAI: usa la sintassi più recente con l’endpoint di chat completions
2. Gestione sicura della API key: carica la chiave dalle variabili d’ambiente usando dotenv
3. Analisi personalizzabile: offre analisi di base o dettagliata in base alle preferenze dell’utente
4. Output strutturato: restituisce categoria di sentiment, score di confidenza, spiegazione e analisi dettagliata opzionale
5. Elaborazione JSON: gestisce risposte JSON strutturate da OpenAI
6. Strategia di test: simula la chiamata all’API OpenAI per i test senza consumare crediti reali

Questo blocco dimostra come integrare servizi IA allo stato dell’arte per potenziare le capacità dei tuoi agenti. L’integrazione con OpenAI abilita analisi testuali sofisticate che sarebbero difficili da implementare con semplici approcci basati su regole.

Quando scrivi i tuoi blocchi, considera sempre:

• Come gestire in sicurezza le API key
• Fornire messaggi di errore chiari in caso di fallimenti dell’API
• Progettare input che consentano flessibilità nell’uso del blocco
• Strutturare gli output per essere facilmente consumati dai blocchi a valle

Per informazioni più dettagliate sulla creazione di blocchi personalizzati, inclusi tipi di campo, autenticazione, integrazione di webhook e best practice, vedi la documentazione ufficiale dei blocchi AutoGPT.

Conclusione

AutoGPT offre una potente piattaforma per creare e distribuire agenti IA autonomi tramite la sua intuitiva interfaccia a blocchi. Questo tutorial ti ha guidato nell’intero processo — dall’installazione e configurazione locali alla comprensione della UI, creazione di agenti di base ed estensione delle funzionalità con blocchi personalizzati. 

Abbracciando l’architettura modulare di AutoGPT, i professionisti tecnici possono automatizzare workflow complessi senza conoscenze di coding approfondite, mantenendo al contempo la flessibilità di aggiungere capacità personalizzate quando necessario.

Per chi desidera costruire su queste basi ed esplorare ulteriormente gli agenti IA, la documentazione ufficiale di AutoGPT fornisce indicazioni complete, mentre DataCamp offre risorse complementari come Capire gli agenti IA e Fondamenti di ChatGPT. 

Il corso Introduzione ai GPT può aiutarti a consolidare la comprensione dei large language model, mentre Costruire chatbot RAG per documentazione tecnica dimostra un’altra applicazione pratica degli agenti IA. Continuando a sperimentare con gli agenti IA, potresti voler dare un’occhiata anche a nuovi strumenti come Mistral Agents API, Dify AI e Langflow.