Orchestrate a multi-agent system 🤖🤝🤖

In questo quaderno faremo un browser web multi-agente: un sistema agenziale con diversi agenti che collaborano per risolvere problemi utilizzando il web!

Si tratta di una semplice gerarchia, che utilizza un elemento Agente gestito per avvolgere l'agente di ricerca web gestito:

Copiato

              +----------------+
              | Agente manager
              +----------------+
                       |
        _______________|______________
       | |
  Interprete di codice +--------------------------------+
       strumento | Agente gestito |
                     | +------------------+ |
                     | | Agente di ricerca web | |
                     | +------------------+ |
                     | | | |
                     | Strumento di ricerca web | |
                     | Strumento per visitare le pagine web
                     +--------------------------------+

Impostiamo questo sistema.

Eseguire la riga seguente per installare le dipendenze richieste:

Copiato

pip installa markdownify duckduckgo-search smolagents --upgrade -q

Effettuiamo il login per chiamare l'API HF Inference:

Copiato

da huggingface_hub importa login

login()

⚡️ Il nostro agente sarà alimentato da Qwen/Qwen2.5-Coder-32B-Istruzione utilizzando HfApiModel che utilizza l'API di inferenza di HF: l'API di inferenza consente di eseguire rapidamente e facilmente qualsiasi modello di SO.

Nota: L'Inference API ospita modelli basati su vari criteri e i modelli distribuiti possono essere aggiornati o sostituiti senza preavviso. Per saperne di più qui.

Copiato

model_id = "Qwen/Qwen2.5-Coder-32B-Istruzione"

🔍 Creare uno strumento di ricerca sul web #

Per la navigazione sul web, possiamo già utilizzare il nostro preesistente DuckDuckGoSearchTool per fornire un equivalente della ricerca su Google.

Ma poi dovremo anche essere in grado di accedere alla pagina trovata dal metodo DuckDuckGoSearchTool. Per farlo, si può importare la libreria incorporata Strumento per visitare la pagina webma lo costruiremo di nuovo per vedere come si fa.

Creiamo quindi il nostro Strumento per visitare la pagina web da zero utilizzando markdownify.

Copiato

importare re
importare richieste
da markdownify import markdownify
da requests.exceptions import RequestException
da smolagents importare tool


@strumento
def visit_webpage(url: str) -> str:
    """Visita una pagina web all'URL indicato e ne restituisce il contenuto come stringa markdown.

    Args:
        url: L'URL della pagina web da visitare.

    Restituisce:
        Il contenuto della pagina web convertito in Markdown o un messaggio di errore se la richiesta fallisce.
    """
    prova:
        # Inviare una richiesta GET all'URL
        response = requests.get(url)
        response.raise_for_status()  # Sollevare un'eccezione per i codici di stato errati

        # Convertire il contenuto HTML in Markdown
        markdown_content = markdownify(response.text).strip()

        # Rimuovere le interruzioni di riga multiple
        markdown_content = re.sub(r"\n{3,}", "\n", markdown_content)

        restituire markdown_content

    tranne RequestException as e:
        return f "Errore nel recupero della pagina web: {str(e)}"
    except Exception as e:
        return f "Si è verificato un errore imprevisto: {str(e)}"

Ok, ora inizializziamo e testiamo il nostro strumento!

Copiato

print(visit_webpage("https://en.wikipedia.org/wiki/Hugging_Face")[:500])

Costruire il nostro sistema multi-agente 🤖🤝🤖 #

Ora che abbiamo tutti gli strumenti ricerca e visita_pagina_web, possiamo usarli per creare l'agente web.

Quale configurazione scegliere per questo agente?

La navigazione web è un'attività a linea temporale singola che non richiede chiamate di strumenti in parallelo, per cui la chiamata di strumenti JSON funziona bene. Abbiamo quindi scelto un metodo Agente Json.
Inoltre, dato che a volte la ricerca sul web richiede l'esplorazione di molte pagine prima di trovare la risposta corretta, preferiamo aumentare il numero di pagine di ricerca. passi_massimi a 10.

Copiato

da smolagents importiamo (
    CodeAgent,
    ToolCallingAgent,
    HfApiModel,
    ManagedAgent,
    DuckDuckGoSearchTool,
    LiteLLMModel,
)

modello = HfApiModel(model_id)

web_agent = ToolCallingAgent(
    tools=[DuckDuckGoSearchTool(), visit_webpage],
    modello=modello,
    max_steps=10,
)

Si avvolge poi questo agente in un oggetto Agente gestito che lo renderà richiamabile dal suo agente gestore.

Copiato

managed_web_agent = ManagedAgent(
    agent=web_agent,
    name="ricerca",
    description="Esegue ricerche sul Web per voi. Dategli la vostra query come argomento",
)

Infine, creiamo un agente manager e, al momento dell'inizializzazione, gli passiamo il nostro agente gestito nella sua cartella agenti gestiti argomento.

Poiché questo agente è quello che ha il compito di pianificare e pensare, un ragionamento avanzato sarà utile, per cui un CodiceAgente sarà la scelta migliore.

Inoltre, vogliamo porre una domanda che riguardi l'anno in corso ed esegua calcoli aggiuntivi sui dati: aggiungiamo quindi additional_authorized_imports=["time", "numpy", "pandas"]nel caso in cui l'agente abbia bisogno di questi pacchetti.

Copiato

manager_agent = CodeAgent(
    strumenti=[],
    model=modello,
    managed_agents=[managed_web_agent],
    additional_authorized_imports=["time", "numpy", "pandas"],
)

Questo è tutto! Ora facciamo funzionare il nostro sistema! Selezioniamo una domanda che richiede calcoli e ricerche:

Copiato

answer = manager_agent.run("Se la formazione LLM continua a crescere al ritmo attuale fino al 2030, quale sarebbe l'energia elettrica in GW necessaria per alimentare i maggiori corsi di formazione entro il 2030? A quanto corrisponderebbe, rispetto ad alcuni Paesi? Si prega di fornire una fonte per i numeri utilizzati").

La risposta è questo rapporto:

Copiato

In base alle attuali proiezioni di crescita e alle stime del consumo energetico, se i corsi di formazione LLM continueranno a crescere al ritmo attuale fino al 2030
ritmo attuale fino al 2030:

1. L'energia elettrica necessaria per alimentare i maggiori corsi di formazione entro il 2030 sarebbe di circa 303,74 GW, che si traduce in circa 2.660.762 GWh/anno.
che si traduce in circa 2.660.762 GWh/anno.

2. Confrontando questo dato con il consumo di elettricità dei Paesi:
   - Sarebbe equivalente a circa 34% del consumo totale di elettricità della Cina.
   - Supererebbe il consumo totale di elettricità di India (184%), Russia (267%) e Giappone (291%).
   - Sarebbe quasi 9 volte il consumo di elettricità di Paesi come l'Italia o il Messico.

3. Fonte dei numeri:
   - La stima iniziale di 5 GW per la futura formazione LLM proviene da Matt Garman, CEO di AWS.
   - La proiezione di crescita ha utilizzato un CAGR di 79,80% ricavato da una ricerca di mercato di Springs.
   - I dati sul consumo di energia elettrica del Paese provengono dalla U.S. Energy Information Administration, principalmente per il 2021.
2021.

Sembra che ci sia bisogno di impianti di potenza di dimensioni ragguardevoli se la ipotesi di scala continua a valere.

I nostri agenti sono riusciti a collaborare in modo efficiente per risolvere il compito! ✅

💡 Si può facilmente estendere questa orchestrazione a più agenti: uno esegue il codice, uno la ricerca sul web, uno gestisce il caricamento dei file...