Creazione di agenti IA collaborativi con CrewAI

Introduzione

Lo sviluppo di agenti AI è una delle frontiere più calde dell'innovazione software. Con l’evolversi della qualità dei modelli linguistici di grandi dimensioni, assisteremo a un aumento dell’integrazione degli agenti AI con i sistemi software esistenti. Con gli agenti AI sarà possibile svolgere attività con comandi vocali o gestuali invece di navigare manualmente tra le applicazioni. Ma in questo momento, lo sviluppo degli agenti è nella sua fase nascente. Stiamo ancora attraversando la fase iniziale di sviluppo di infrastrutture, strumenti e framework, simile a Internet degli anni ’1990. Quindi, in questo articolo discuteremo di un altro framework per lo sviluppo di agenti chiamato CrewAI.

obiettivi formativi

• Ulteriori informazioni sugli agenti IA.
• Esplora CrewAI: uno strumento open source per la creazione di agenti.
• Crea un team di intelligenza artificiale collaborativo per scrivere contenuti.
• Esplora casi d'uso reali degli agenti IA.

Questo articolo è stato pubblicato come parte di Blogathon sulla scienza dei dati.

Cosa sono gli agenti AI?

I modelli linguistici eccellono nella traduzione, nel riepilogo e nel ragionamento. Tuttavia, puoi fare così tanto con loro. Uno dei modi per realizzare appieno il potenziale del ragionamento è rendere agenti i LLM. Gli agenti AI sono LLM potenziati con gli strumenti e le istruzioni giusti. Questi agenti possono automatizzare la navigazione, il web scraping, l'esecuzione di query SQL, le operazioni sui file e altro ancora. Gli agenti utilizzano la capacità di ragionamento degli LLM per selezionare uno strumento in base alle esigenze attuali. Ma invece di utilizzare un singolo agente per un compito, possiamo unirne molti per portare a termine compiti complessi.

Langchain è lo strumento predefinito che viene in mente quando si parla di agenti AI. Tuttavia, orchestrare manualmente gli agenti AI per eseguire attività collaborative sarebbe impegnativo con Langchain. È qui che entra in gioco CrewAI.

Cos'è CrewAI?

CrewAI è un framework open source per orchestrare giochi di ruolo e agenti IA autonomi. Aiuta a creare agenti AI collaborativi per raggiungere facilmente obiettivi complessi. Il framework è progettato per consentire agli agenti di intelligenza artificiale di assumere ruoli, delegare compiti e condividere obiettivi, proprio come un equipaggio del mondo reale. Queste sono alcune delle caratteristiche uniche di CrewAI:

• Agenti basati sui ruoli: possiamo definire agenti con ruoli, obiettivi e retroscena specifici per fornire più contesto ai LLM prima della generazione di risposte.
• Gestione delle attività: definisci le attività con strumenti e assegnale dinamicamente agli agenti.
• Delega tra agenti: gli agenti possono delegare attività ad altri agenti per collaborare in modo efficace.

Di seguito è riportata una rappresentazione della mappa mentale di CrewAI.

CrewAI si integra perfettamente con l'ecosistema Langchain. Ciò significa che possiamo utilizzare gli strumenti Langchain e le integrazioni LLM con CrewAI. 

Costruire un equipaggio AI collaborativo

Per comprendere meglio CrewAI, creiamo agenti AI collaborativi per la scrittura di contenuti creativi. Per questo, definiremo agenti, strumenti e i rispettivi compiti per ciascun agente. Trattandosi di un team per la scrittura dei contenuti, definiremo tre agenti separati, come un analista di idee, uno scrittore e un editore. Ad ogni agente verrà assegnato un compito.

L'agente analista sarà responsabile dell'analisi dell'idea e della preparazione di un progetto completo per la scrittura del contenuto. L'agente dello scrittore preparerà la bozza dell'articolo e, infine, l'editor sarà responsabile della formattazione, modifica e correzione della bozza. Come sappiamo, CrewAI ci consente di potenziare gli agenti con strumenti personalizzati. Aumenteremo l'editor con uno strumento per salvarlo sul disco locale. Ma per realizzare tutte queste cose, abbiamo bisogno di un LLM. Qui utilizzeremo il modello Gemini di Google.

Approfondiamo la codifica

Come con qualsiasi progetto Python, crea un ambiente virtuale e installa le dipendenze. Avremo bisogno della libreria Crewai e dell'implementazione di Langchain GoogleGenAI. Puoi utilizzare altri LLM, come i modelli ad accesso aperto da Insieme, Qualsiasi scalao modelli OpenAI.

pip install crewai langchain-google-genai

Il passo successivo è definire il nostro LLM e gli agenti collaborativi. Crea un file separato denominato agenti.py per definire gli agenti.

import os

from crewai import Agent
from langchain.tools import tool
from langchain_google_genai import GoogleGenerativeAI

GOOGLE_API_KEY = "Your Key"
llm = GoogleGenerativeAI(
           model="gemini-pro", 
           google_api_key=GOOGLE_API_KEY
           )

Definiamo lo strumento di salvataggio dei file.

class FileTools:

    @tool("Write File with content")
    def write_file(data: str):
        """Useful to write a file to a given path with a given content. 
           The input to this tool should be a pipe (|) separated text 
           of length two, representing the full path of the file, 
           including the ./lore/, and the written content you want to write to it.
        """
        try:
            path, content = data.split("|")
            path = path.replace("n", "").replace(" ", "").replace("`", "")
            if not path.startswith("./lore"):
                path = f"./lore/{path}"
            with open(path, "w") as f:
                f.write(content)
            return f"File written to {path}."
        except Exception:
            return "Error with the input format for the tool."

Il metodo write_file sopra è decorato con la funzione strumento di Langchain. Poiché CrewAI utilizza Langchain dietro le quinte, gli strumenti devono essere conformi alle convenzioni di Langchain. La funzione prevede una singola stringa con due parti, un percorso file e contenuto separato da una barra verticale (|). Le stringhe doc del metodo vengono utilizzate anche come contesto aggiunto per la funzione. Quindi, assicurati di fornire informazioni dettagliate sul metodo.

Definiamo gli agenti

idea_analyst = Agent(
    role = "Idea Analyst",
    goal = "Comprehensively analyse an idea to prepare blueprints for the article to be written",
    backstory="""You are an experienced content analyst, well versed in analyzing 
    an idea and preparing a blueprint for it.""",
    llm = llm,
    verbose=True
)
writer = Agent(
    role = "Fiction Writer",
    goal = "Write compelling fantasy and sci-fi fictions from the ideas given by the analyst",
    backstory="""A renowned fiction-writer with 2 times NYT 
    a best-selling author in the fiction and sci-fi category.""",
    llm=llm,
    verbose=True
)

editor = Agent(
    role= "Content Editor",
    goal = "Edit contents written by writer",
    backstory="""You are an experienced  editor with years of 
    experience in editing books and stories.""",
    llm = llm,
    tools=[FileTools.write_file],
    verbose=True
)

Abbiamo tre agenti, ciascuno con un ruolo, un obiettivo e una storia diversa. Queste informazioni vengono utilizzate come suggerimento per il LLM per fornire più contesto. All'agente editor è associato uno strumento di scrittura.

La prossima cosa è definire i compiti. Per questo, crea un file diverso task.py.

from textwrap import dedent


class CreateTasks:

    def expand_idea():
        return dedent(""" Analyse the given task {idea}. Prepare comprehensive pin-points
                for accomplishing the given task.
                Make sure the ideas are to the point, coherent, and compelling.
                Make sure you abide by the rules. Don't use any tools.
                
                RULES:
                - Write ideas in bullet points.
                - Avoid adult ideas.
            """)
    def write():
        return dedent("""Write a compelling story in 1200 words based on the blueprint 
        ideas given by the Idea 
              analyst.
              Make sure the contents are coherent, easily communicable, and captivating.
               Don't use any tools.

              Make sure you abide by the rules.

              RULES:
              - Writing must be grammatically correct.
              - Use as little jargon as possible

              """)
    def edit():
        return dedent("""
    Look for any grammatical mistakes, edit, and format if needed.
    Add title and subtitles to the text when needed.
    Do not shorten the content or add comments.
    Create a suitable filename for the content with the .txt extension.
    You MUST use the tool to save it to the path ./lore/(your title.txt).
            """)

Le attività qui sono piani d'azione dettagliati che ti aspetti che gli agenti eseguano.

Infine, crea il file main.py in cui assembliamo gli agenti e le attività per creare un equipaggio funzionale.

from textwrap import dedent

from crewai import Crew, Task

from agents import editor, idea_analyst, writer
from tasks import CreateTasks


class ContentWritingCrew():
    def __init__(self, idea):
        self.idea = idea
    def __call__(self):
        tasks = self._create_tasks()
        crew = Crew(
            tasks=tasks,
            agents=[idea_analyst, writer, editor],
            verbose=True
            )
        result = crew.kickoff()
        return result

    def _create_tasks(self):
        idea = CreateTasks.expand_idea().format(idea=self.idea)
        expand_idea_task = Task(
            description=idea,
            agent = idea_analyst
        )
        write_task =  Task(
            description=CreateTasks.write(),
            agent=writer
        )
        edit_task = Task(
            description=CreateTasks.edit(),
            agent=editor
        )
        return [expand_idea_task, write_task, edit_task]

if __name__ == "__main__":
    dir = "./lore"
    if not os.path.exists(dir):
        os.mkdir(dir)
    idea = input("idea: ")
    my_crew = ContentWritingCrew(idea=idea)
    result = my_crew()
    print(dedent(result))

Nel codice precedente, abbiamo definito una classe ContentWritingCrew che accetta una stringa di idee dall'utente. Il metodo _create_tasks crea attività. Il metodo __call__ inizializza e dà il via all'equipaggio. Una volta eseguito lo script, puoi osservare la catena di azioni sul terminale o sul notebook. Le attività verranno eseguite nell'ordine in cui vengono definite dall'equipaggio. Ecco uno snapshot del registro di esecuzione.

Questo è il registro di esecuzione per l'agente finale. cioè redattore. Modifica la bozza ricevuta dall'agente dello scrittore e utilizza lo strumento di scrittura file per salvare il file con un nome file adatto.

Questo è il flusso di lavoro generale per la creazione di agenti AI collaborativi con CrewAI. Puoi abbinare altri strumenti Langchain o creare strumenti personalizzati con suggerimenti efficienti per eseguire attività più complesse.

Ecco il repository GitHub per i codici: sunilkumardash9/ContentWritingAgents.

Repository di replica: Sunil-KumarKu17/ColborativeAIAgent

Casi d'uso nel mondo reale

Gli agenti IA autonomi possono avere molti casi d'uso. Dagli assistenti personali agli istruttori virtuali. Ecco alcuni casi d'uso degli agenti AI.

• Assistente personale dell'intelligenza artificiale: Gli Assistenti Personali saranno presto parte integrante di noi. Un assistente simile a Jarvis che elabora tutti i tuoi dati fornisce informazioni dettagliate mentre procedi e gestisce da solo compiti banali.
• Interpreti di codice: L'interprete di codice di OpenAI è un brillante esempio di agente AI. L'interprete può eseguire qualsiasi script Python e restituire i risultati in risposta a un prompt di testo. Questo è probabilmente l'agente di maggior successo fino ad oggi.
• Istruttori virtuali: Con l'evoluzione della tecnologia dell'intelligenza artificiale, possiamo aspettarci istruttori virtuali in molti campi come l'istruzione, la formazione, ecc.
• Primo software dell'agente: Un enorme potenziale caso d'uso degli agenti IA è lo sviluppo di software agent first. Invece di navigare manualmente e fare clic sui pulsanti per svolgere le attività, gli agenti AI le eseguiranno automaticamente in base ai comandi vocali.
• Calcolo spaziale: Man mano che la tecnologia AR/VR si evolve, gli agenti IA svolgeranno un ruolo cruciale nel colmare il divario tra il mondo virtuale e quello reale.

Conclusione

Siamo ancora nelle fasi iniziali dello sviluppo dell’agente AI. Attualmente, per ottenere il miglior risultato possibile dagli agenti IA, dobbiamo fare affidamento su GPT-4, ed è costoso. Ma man mano che i modelli open source raggiungeranno GPT-4, otterremo opzioni migliori per eseguire agenti AI in modo efficiente a un costo ragionevole. D’altro canto, le strutture per lo sviluppo degli agenti stanno progredendo rapidamente. Man mano che andiamo avanti, i framework consentiranno agli agenti di eseguire compiti ancora più complessi.

 Punti chiave

• Gli agenti di intelligenza artificiale sfruttano la capacità di ragionamento degli LLM per selezionare strumenti appropriati per svolgere compiti complessi.
• CrewAI è un framework open source per la creazione di agenti AI collaborativi.
• La caratteristica unica di CrewAI include agenti basati sui ruoli, delega autonoma tra agenti e gestione flessibile delle attività.
• CrewAI si integra perfettamente con l'ecosistema Langchain esistente. Possiamo utilizzare gli strumenti Langchain e le integrazioni LLM con CrewAI.

Domande frequenti

I media mostrati in questo articolo non sono di proprietà di Analytics Vidhya e vengono utilizzati a discrezione dell'autore.

Leggi Anche

• Distribuzione di contenuti basati su SEO e PR. Ricevi amplificazione oggi.
• PlatoData.Network Generativo verticale Ai. Potenzia te stesso. Accedi qui.
• PlatoAiStream. Intelligenza Web3. Conoscenza amplificata. Accedi qui.
• PlatoneESG. Carbonio, Tecnologia pulita, Energia, Ambiente, Solare, Gestione dei rifiuti. Accedi qui.
• Platone Salute. Intelligence sulle biotecnologie e sulle sperimentazioni cliniche. Accedi qui.
• Fonte: https://www.analyticsvidhya.com/blog/2024/01/building-collaborative-ai-agents-with-crewai/