Costruisci un assistente di ricerca sull'intelligenza artificiale utilizzando CrewAI e Composio | Intelligenza-Artificiale

introduzione

Con ogni iterazione dello sviluppo LLM, ci stiamo avvicinando all'era degli agenti AI. Un’era in cui gli agenti AI sono profondamente integrati nei flussi di lavoro del software, gestendo la maggior parte delle attività, dall’automazione delle attività di produttività personale come la pianificazione di riunioni e la gestione delle e-mail alla fornitura di promemoria personalizzati e l’organizzazione di elenchi di cose da fare quotidiane. A livello aziendale, gli agenti AI possono semplificare le operazioni automatizzando l’assistenza clienti, ottimizzando la logistica della catena di fornitura, migliorando l’analisi dei dati e migliorando i processi decisionali. Ciò consente alle aziende di operare in modo più efficiente, ridurre i costi e concentrare gli sforzi umani su attività più creative. Ma costruire agenti che funzionino non è un compito facile, soprattutto in produzione. Si stanno compiendo molti sforzi per costruire l’ecosistema degli strumenti per rendere gli agenti utili e affidabili. Questo articolo esplorerà due di questi strumenti, CrewAI e Composio, per creare utili agenti IA utilizzando Claude Sonet.

Obiettivo di apprendimento

• Comprendere gli agenti IA.
• Scopri CrewAI, uno strumento per orchestrare gli agenti IA.
• Esplora Compoiso: una piattaforma per l'integrazione di strumenti con gli agenti.
• Crea un assistente di ricerca sull'intelligenza artificiale con l'integrazione di Slack e Notion.

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

Cosa sono gli agenti AI?

Il termine agenti AI viene utilizzato ultimamente in tutti i discorsi moderni sull'intelligenza artificiale. Quindi, cosa sono gli agenti AI? Gli agenti sono pezzi di software che possono interagire dinamicamente con il loro ambiente tramite una serie di strumenti e l'”AI” in “agenti AI” si riferisce ai modelli linguistici di grandi dimensioni o ai grandi Modelli multimodali.

Come sappiamo, gli LLM possiedono nei loro pesi una forma condensata di conoscenza umana, che consente loro di analizzare e ragionare passo dopo passo su un compito complesso. Quando i LLM hanno accesso agli strumenti giusti, possono scomporre una dichiarazione del problema e utilizzare gli strumenti giusti per eseguire le attività come e quando necessario. Il miglior esempio di ciò sarebbe Chatgpt l'app stessa. Ha accesso all'interprete del codice, a Internet e a Dalle. In base al prompt fornito, decide cosa utilizzare e quando. COSÌ, Agenti dell'intelligenza artificiale sono LLM arricchiti con strumenti e obiettivi.

Tuttavia, l’utilizzo diretto degli strumenti con LLM potrebbe non essere sufficiente per eseguire attività complesse. Dobbiamo orchestrare più agenti con strumenti e obiettivi definiti.

Cos'è CrewAI?

CrewAI è uno strumento open source per orchestrare più agenti IA per eseguire attività complesse. Fornisce un approccio collaborativo in cui gli agenti possono assumere ruoli, delegare compiti e condividere obiettivi, simile a un equipaggio del mondo reale. Queste sono le caratteristiche principali di CrewAI.

• Agenti: gli agenti sono unità autonome responsabili del ragionamento, della delega dei compiti e della comunicazione con altri agenti simili ai membri del team in un team del mondo reale.
• Compiti: i compiti sono incarichi specifici assegnati agli agenti. Descrive in dettaglio tutti i passaggi e le azioni che un agente deve intraprendere per raggiungere un obiettivo richiesto.
• Strumenti: gli strumenti sono necessari per eseguire compiti che vanno oltre LLMcome web scraping, risposta alle e-mail, pianificazione delle attività, ecc.
• Processo: i processi in CrewAI orchestrano l'esecuzione delle attività da parte degli agenti. Ciò garantisce che le attività vengano distribuite ed eseguite in modo efficiente dagli agenti in modo predefinito. Il processo è sequenziale, in cui le attività vengono completate in sequenza, o gerarchico, in cui le attività vengono eseguite in base a una gerarchia manageriale.
• Equipaggi: gli equipaggi di CrewAI sono agenti collaborativi con compiti e strumenti che lavorano per portare a termine compiti complessi.

Ecco una mappa mentale per CrewAI.

Cos'è Composio?

Composizione è una piattaforma che fornisce oltre 100 strumenti, come Slack, GitHub, Discord, ecc., con azioni e trigger per integrarsi con i flussi di lavoro dell'intelligenza artificiale. Può essere integrato con LangChainAutogen e CrewAI per rendere gli agenti utili e affidabili. Ciò rende molto più semplice per gli agenti lavorare con app esterne. In questo articolo utilizzeremo gli strumenti Slack e Notion di Composio per creare un assistente AI che ascolta un canale Slack e scrive un rapporto completo sull'argomento in un file Notion. Quindi passiamo alla parte di codifica.

Costruire un assistente di ricerca sull'intelligenza artificiale

Definiamo l'obiettivo del nostro assistente di ricerca sull'intelligenza artificiale. Pertanto, il nostro assistente di ricerca sull'intelligenza artificiale è costituito da un insieme di agenti che lavorano in collaborazione per svolgere il compito. L'assistente ascolta un canale Slack specifico tramite un bot Slack e quando un messaggio viene inviato al canale, l'equipaggio dell'intelligenza artificiale entra in azione. Prende il messaggio Slack come compito principale, distribuisce in sequenza i compiti all'agente di ricerca per fornire i punti urgenti, a un analista per descrivere ed espandere tali punti, a un agente Notion per creare e scrivere i contenuti in un file di testo e, infine, l'agente Slack deve rispondere in un canale Slack con il documento di testo.

Ecco la rappresentazione visiva del flusso di lavoro.

Quindi, ecco come costruiremo.

• Configura un ambiente di sviluppo utilizzando Venv o Poetry.
• Configura il set di strumenti Composio per Notion e Slack.
• Crea agenti utilizzando CrewAI, set di strumenti Composio e Claude Sonnet di Anthropic (è possibile utilizzare altri modelli).
• Costruisci un server Flask con tunneling Ngrok che ascolti il ​​bot Slack.

Passaggio 1: configurazione dell'ambiente

Per iniziare, crea un ambiente virtuale e installa le dipendenze elencate di seguito.

crewai(tools)==0.*
composio-crewai==0.2.*
composio-langchain==0.2.*
composio-core==0.2.*
flask==3.0.3
python-dotenv==1.0.1
langchain-anthropic

Se usi Poesia, clona il file deposito e corri

poetry install
poetry shell

Abbiamo anche bisogno di un tunnel Ngrok sicuro affinché il server Flask locale riceva i trigger dal bot Slack. Ngrok è un servizio di tunneling sicuro che espone il server locale a Internet per attività di sviluppo e test. Quindi, installa gonna, a seconda del sistema operativo del sistema. Potrebbe essere necessario creare un account con loro. Una volta scaricato, colleghiamo la porta 2000 a Ngrok, dove ospiteremo il nostro server Flask.

ngrok http 2000

Questo dovrebbe avviare un tunnel Ngrok verso la porta 2000.

Inoltre, dobbiamo definire alcune variabili di ambiente, an API antropica chiave, un ID canale Slack e un ID trigger. Quindi, crea queste variabili in un file .env.

ANTHROPIC_API_KEY=

CHANNEL_ID=

TRIGGER_ID=

Aggiungi la tua chiave API e l'ID del canale Slack. Puoi trovare l'ID del canale Slack dal suo URL, che di solito inizia con “C*”; ad esempio, C074RUF0UQ5 è l'ID del canale https://app.slack.com/client/T074SRB4FGS/C073RUF0UQ5. Imposteremo il TRIGGER_ID nella sezione successiva.

Ora dobbiamo configurare il nostro set di strumenti Notion e Slack da Composio. Per fare ciò, utilizza la CLI Composio per aggiungere strumenti.

poetry run composio-cli add notion
poetry run composio-cli add slack

Ora imposta la richiamata del trigger sull'URL di Ngrok. Questo collegherà il bot Slack al server Flask tramite il tunnel Ngrok.

poetry run composio-cli set global-trigger-callback "<ngrok-url>"

Sostituire con l'URL .app di Ngrok mostrato nel terminale.

Ora abilita il trigger di ricezione Slack. Ciò consentirà al bot Slack di ricevere messaggi dal canale Slack e di inviarli al server con tunnel.

poetry run composio-cli enable-trigger slack_receive_message

Verrà generato un TRIGGER_ID. Ora aggiorna lo stesso in .env.

Costruisci agenti con CrewAI

Ora costruiamo gli agenti. In questa configurazione, definiamo quattro diversi agenti: un ricercatore per suddividere i compiti, un analista per analizzare i compiti, un agente nozione per scrivere il contenuto in un file di testo e un agente Slack per inviare la conferma dell'attività insieme al testo file sul canale Slack.

Definire i ruoli e le attività dell'agente

Innanzitutto, dobbiamo definire i ruoli e le attività dell'agente. Possiamo definirli in due diversi file Yaml: i file di configurazione Yaml per gli agenti.

researcher:
  role: >
    {topic} Senior Data Researcher
  goal: >
    Uncover cutting-edge developments in {topic}
  backstory: >
    You're a seasoned researcher with a knack for uncovering the latest
    developments in {topic}. Known for your ability to find the most relevant
    information and present it clearly and concisely.

reporting_analyst:
  role: >
    {topic} Reporting Analyst
  goal: >
    Create detailed reports based on {topic} data analysis and research findings
  backstory: >
    You're a meticulous analyst with a keen eye for detail. You're known for
    your ability to turn complex data into clear and concise reports, making
    it easy for others to understand and act on the information you provide.

notion_agent:
  role: >
    Notion Updater
  goal: >
    You take action on Notion using the Notion API
  backstory: >
    You are AI agent that is responsible for taking actions on Notion on 
    users behalf. You need to take action on Notion using Notion APIs

slack_agent:
  role: >
    Slack Updater
  goal: >
    You take action on Slack using the Notion API
  backstory: >
    You are an AI agent that is responsible for taking actions on Slack on 
    users behalf. You need to take action on Slack using Slack APIs

Definire un file simile per le attività.

research_task:
  description: >
    Conduct a thorough research about {topic}
    Make sure you find any interesting and relevant information given
    the current year is 2024.
  expected_output: >
    A list with 10 bullet points of the most relevant information about {topic}.

reporting_task:
  description: >
    Review the context you got and expand each topic into a full section for a report.
    Make sure the report is detailed and contains any and all relevant information.
  expected_output: >
    A fully fledge report with the main topics, each with a full section of information.
    Formated as markdown without missing anything.

notion_task:
  description: >
    Write a document on the Notion of the summary of the given content.
  expected_output: >
    A Notion document with a title and contents.

slack_task:
  description: >
    Write a message on slack channel 'random' that summarizes the complete Crewai 
    research activity. 
    Write a summary 
    of your findings and attach the report.
  expected_output: >
    A Slack message with a summary of entire actions done and final output.  

Costruisci agenti

Crea un nuovo file e importa librerie e variabili env.

import os

from composio_crewai import App, ComposioToolset
from crewai import Agent, Crew, Process, Task
from crewai.project import CrewBase, agent, crew, task
from langchain_anthropic import ChatAnthropic


ANTHROPIC_API_KEY = os.environ.get("ANTHROPIC_API_KEY")

if ANTHROPIC_API_KEY is None:
    print("Please set ANTHROPIC_API_KEY environment variable in the .env file")
    exit(1)

Definire il set di strumenti LLM e Composio.

llm = ChatAnthropic(
    model_name="claude-3-sonnet-20240229",
    api_key=ANTHROPIC_API_KEY
)

notion_composio_toolset = ComposioToolset(apps=(App.NOTION))
slack_composio_toolset = ComposioToolset(apps=(App.SLACK))

CrewAI fornisce decoratori per agenti, attività e personale per definirli comodamente.

@CrewBase
class ClientCrew:
    """Class representing the Client crew"""

    agents_config = "config/agents.yaml"
    tasks_config = "config/tasks.yaml"

    @agent
    def researcher(self) -> Agent:
        """Create a researcher agent"""
        return Agent(
            config=self.agents_config("researcher"),
            verbose=True,
            llm=llm,
        )

    @agent
    def reporting_analyst(self) -> Agent:
        """Create a reporting analyst agent"""
        return Agent(
            config=self.agents_config("reporting_analyst"), verbose=True, llm=llm
        )

    @agent
    def notion_agent(self) -> Agent:
        """Create a notion agent"""
        return Agent(
            config=self.agents_config("notion_agent"),
            verbose=True,
            tools=notion_composio_toolset,
            llm=llm,
        )

    @agent
    def slack_agent(self) -> Agent:
        """Create a slack agent"""
        return Agent(
            config=self.agents_config("slack_agent"),
            verbose=True,
            tools=slack_composio_toolset,
            llm=llm,
        )

    @task
    def research_task(self) -> Task:
        """Create a research task"""
        return Task(config=self.tasks_config("research_task"), agent=self.researcher())

    @task
    def reporting_task(self) -> Task:
        """Create a reporting task"""
        return Task(
            config=self.tasks_config("reporting_task"),
            agent=self.reporting_analyst(),
            output_file="report.md",
        )

    @task
    def notion_task(self) -> Task:
        """Create a notion task"""
        return Task(
            config=self.tasks_config("notion_task"),
            agent=self.notion_agent(),
            tools=notion_composio_toolset,
        )

    @task
    def slack_task(self) -> Task:
        """Create a slack task"""
        return Task(
            config=self.tasks_config("slack_task"),
            agent=self.slack_agent(),
            tools=slack_composio_toolset,
        )

    @crew
    def crew(self) -> Crew:
        """Create the Client crew"""
        return Crew(
            agents=self.agents, tasks=self.tasks, process=Process.sequential, verbose=2
        )

Questo è fatto. Abbiamo definito gli agenti, i compiti, il processo e l'equipaggio richiesti.

Crea il server Flask

Ora dobbiamo definire un server Flask. L'API del server ha un solo endpoint che riceve il messaggio dal bot e mette in azione la squadra.

# main.py

import os

from dotenv import load_dotenv
from flask import Flask, request

load_dotenv()

from client import ClientCrew

app = Flask(__name__)

TRIGGER_ID = os.environ.get("TRIGGER_ID", None)
CHANNEL_ID = os.environ.get("CHANNEL_ID", None)

if TRIGGER_ID is None or CHANNEL_ID is None:
    print("Please set TRIGGER_ID and CHANNEL_ID environment variables in the .env file")
    exit(1)

def run_crew(topic: str):
    inputs = {"topic": topic}
    ClientCrew().crew().kickoff(inputs=inputs)

async def async_run_crew(channel, text, user):
    if channel == CHANNEL_ID:
        run_crew(text)
    return "Crew run initiated", 200


@app.route("https://www.analyticsvidhya.com/", methods=("POST"))
async def webhook():
    payload = request.json

    message_payload = payload.get("payload", {})
    channel = message_payload.get("channel", "")

    if channel == CHANNEL_ID:
        print("Payload received", payload)

    text = message_payload.get("text", "")
    user = message_payload.get("user", "")

    return await async_run_crew(channel, text=text, user=user)


if __name__ == "__main__":
    app.run(port=2000, debug=True)

Ora esegui main.py per avviare il server Flask sulla porta localhost 2000 dove è stato configurato Ngrok.

python main.py

Vai al canale Slack che hai selezionato e invia un messaggio. Il server lo rileverà immediatamente e verrà avviato il flusso di lavoro dell'equipaggio. Il successo dell'attività dipende dalla qualità del modello. Modelli più grandi e migliori come GPT-4/GPT-4o e Claude Opus tendono ad avere risultati migliori. Sonetto fa un buon lavoro.

L'agente AI ha scritto questo quando gli è stato chiesto di scrivere SRS per un'app di chat React, NodeJs e SQLite.

Ecco il repository dei codici: sunilkumardash9/CrewAIxComposio-Assistente di ricerca

La via da seguire

Abbiamo creato un assistente di ricerca sull'intelligenza artificiale in grado di creare un bel report delle attività e aggiornarlo in un file Notion. Puoi aggiungere agenti con accesso a Internet tramite strumenti SERP per rendere l'assistente più versatile. Il Composio sostiene Oltre 100 strumenti con azioni e trigger per consentire agli agenti di interagire liberamente con servizi di terze parti. Puoi utilizzare gli strumenti per rendere gli agenti migliori e più utili.

Conclusione

Lo sviluppo degli agenti IA è in pieno svolgimento ed è ora l'argomento più caldo nello spazio dell'IA. E come gli strumenti e Infrastruttura LLM migliora, si può prevedere che la prossima generazione di sistemi software avrà agenti di intelligenza artificiale integrati al loro interno. Molti flussi di lavoro banali saranno gestiti da agenti IA dotati di strumenti affidabili e utili. Abbiamo visto un piccolo assaggio durante la creazione del nostro assistente di ricerca AI con l'integrazione degli strumenti Slack e Notion.

Punti chiave

• Gli agenti AI sono LLM o grandi modelli multimodali arricchiti con strumenti e obiettivi, che consentono loro di interagire dinamicamente con il loro ambiente ed eseguire compiti.
• CrewAI è uno strumento open source che orchestra più agenti IA per svolgere in modo collaborativo attività complesse assegnando ruoli, delegando attività e condividendo obiettivi.
• Composio è una piattaforma che offre oltre 100 strumenti, come Slack e GitHubcon azioni e trigger per flussi di lavoro AI. Si integra perfettamente con LangChain, Autogen e CrewAI.
• Integra i set di strumenti Composio con framework di agenti AI come CrewAI per automatizzare i flussi di lavoro che richiedono pianificazione e processi decisionali.

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