Bygga samarbetande AI-agenter med CrewAI

Beskrivning

AI-agentutveckling är en av de hetaste gränserna för mjukvaruinnovation. Allt eftersom kvaliteten på stora språkmodeller utvecklas kommer vi att bevittna en ökning av AI-agentintegration med befintliga programvarusystem. Med AI-agenter kommer det att vara möjligt att utföra uppgifter med röst- eller gestkommandon istället för att manuellt navigera genom applikationer. Men just nu är agentutvecklingen i sitt begynnande skede. Vi går fortfarande igenom den inledande fasen av utveckling av infrastruktur, verktyg och ramverk, liknande Internet på 1990-talet. Så i den här artikeln kommer vi att diskutera ett annat ramverk för agentutveckling som heter CrewAI.

Inlärningsmål

• Lär dig mer om AI-agenter.
• Utforska CrewAI – ett verktyg med öppen källkod för byggagenter.
• Bygg ett samarbetande AI-team för att skriva innehåll.
• Utforska verkliga användningsfall av AI-agenter.

Denna artikel publicerades som en del av Data Science Blogathon.

Vad är AI-agenter?

Språkmodellerna utmärker sig vid översättning, sammanfattning och resonemang. Men du kan göra så mycket med dem. Ett av sätten att fullt ut realisera resonemangspotentialen är att göra LLM:s agent. AI-agenterna är LLM:er utökade med rätt verktyg och uppmaningar. Dessa agenter kan automatisera surfning, webbskrotning, körning av SQL-frågor, filoperationer och mer. Agenterna använder LLM:ers resonemangskapacitet för att välja ett verktyg baserat på nuvarande krav. Men istället för att använda en enda agent för en uppgift, kan vi ensemble många av dem för att utföra komplexa uppgifter.

Langchain är standardverktyget som kommer att tänka på när man diskuterar AI-agenter. Att manuellt orkestrera AI-agenter för att utföra samarbetsuppgifter skulle dock vara en utmaning med Langchain. Det är här CrewAI kommer in i bilden.

Vad är CrewAI?

CrewAI är ett ramverk med öppen källkod för orkestrering av rollspel och autonoma AI-agenter. Det hjälper till att skapa samarbetande AI-agenter för att enkelt uppnå komplexa mål. Ramverket är utformat för att göra det möjligt för AI-agenter att ta på sig roller, delegera uppgifter och dela mål, ungefär som ett verkligt team. Det här är några av de unika egenskaperna hos CrewAI:

• Rollbaserade agenter: Vi kan definiera agenter med specifika roller, mål och bakgrundshistorier för att ge mer sammanhang till LLM innan svarsgenerering.
• Task management: Definiera uppgifter med verktyg och tilldela dem dynamiskt till agenter.
• Delegering mellan agenter: Agenterna kan delegera uppgifter till andra agenter för att samarbeta effektivt.

Nedan är en representation av CrewAI-tankekartan.

CrewAI integreras sömlöst med Langchains ekosystem. Det betyder att vi kan använda Langchain-verktygen och LLM-integrationer med CrewAI. 

Bygga ett Collaborative AI Crew

För att förstå CrewAI bättre, låt oss bygga samarbetande AI-agenter för kreativt innehållsskrivande. För detta kommer vi att definiera agenter, verktyg och respektive uppgifter för varje agent. Eftersom det är ett team för innehållsskrivande kommer vi att definiera tre separata agenter, som en idéanalytiker, en skribent och en redaktör. Varje agent kommer att tilldelas en uppgift.

Analytikern kommer att ansvara för att analysera idén och förbereda en omfattande ritning för att skriva innehållet. Writer-agenten kommer att förbereda utkastet till artikeln, och slutligen kommer redaktören att ansvara för att formatera, redigera och korrigera utkastet. Som vi vet låter CrewAI oss utöka agenter med anpassade verktyg. Vi kommer att utöka redigeraren med ett verktyg för att spara den på den lokala disken. Men för att åstadkomma alla dessa saker behöver vi en LLM. Här kommer vi att använda Googles Gemini-modell.

Låt oss fördjupa oss i kodningen

Som med alla Python-projekt, skapa en virtuell miljö och installera beroenden. Vi kommer att behöva Crewai-biblioteket och Langchains implementering av Google GenAI. Du kan använda andra LLM:er, som open access-modeller från tillsammans, Vilken skala som helst, eller OpenAI-modeller.

pip install crewai langchain-google-genai

Nästa steg är att definiera våra LLM och samarbetsagenter. Skapa en separat fil med namnet agents.py för att definiera agenter.

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
           )

Låt oss definiera verktyget för att spara filer.

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."

Ovanstående write_file-metod är dekorerad med Langchains verktygsfunktion. Eftersom CrewAI använder Langchain under huven måste verktygen följa Langchains konventioner. Funktionen förväntar sig en enda sträng med två delar, en filsökväg och innehåll separerade av ett rör (|). Metodens doc-strängar används också som tillagd kontext för funktionen. Så se till att du ger detaljerad information om metoden.

Låt oss definiera agenterna

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
)

Vi har tre agenter, var och en med olika roller, mål och bakgrund. Denna information används som en uppmaning för LLM att ge mer sammanhang. Redaktören har ett skrivverktyg kopplat till sig.

Nästa sak är att definiera uppgifter. För detta skapar du en annan fil tasks.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).
            """)

Arbetsuppgifterna här är detaljerade handlingsplaner som du förväntar dig att agenterna ska utföra.

Slutligen, skapa main.py-filen där vi sätter ihop agenterna och uppgifterna för att skapa en funktionell besättning.

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))

I koden ovan definierade vi en ContentWritingCrew-klass som accepterar en idésträng från användaren. Metoden _create_tasks skapar uppgifter. Metoden __call__ initierar och sätter igång besättningen. När du har kört skriptet kan du observera kedjan av åtgärder på terminalen eller anteckningsboken. Uppgifterna kommer att utföras i den ordning de definieras av besättningen. Här är en ögonblicksbild av exekveringsloggen.

Detta är exekveringsloggen för den slutliga agenten. dvs redaktör. Den redigerar utkastet från författarens agent och använder filskrivverktyget för att spara filen med ett lämpligt filnamn.

Detta är det allmänna arbetsflödet för att skapa samarbetande AI-agenter med CrewAI. Du kan para ihop andra Langchain-verktyg eller skapa anpassade verktyg med effektiva uppmaningar för att utföra mer komplexa uppgifter.

Här är GitHub-förrådet för koderna: sunilkumardash9/ContentWritingAgents.

Replit arkiv: Sunil-KumarKu17/CollborativeAIAgent

Verkliga användningsfall

Autonoma AI-agenter kan ha många användningsfall. Från personliga assistenter till virtuella instruktörer. Här är några användningsfall av AI-agenter.

• Personlig AI-assistent: Personliga assistenter kommer att bli en integrerad del av oss snart. En Jarvis-liknande assistent som behandlar all din data ger insikt när du går och hanterar triviala uppgifter på egen hand.
• Kodtolkar: OpenAIs kodtolkare är ett lysande exempel på en AI-agent. Tolken kan köra vilket Python-skript som helst och mata ut resultaten som svar på en textprompt. Detta är utan tvekan den mest framgångsrika agenten hittills.
• Virtuella instruktörer: När AI-tekniken utvecklas kan vi förvänta oss virtuella instruktörer inom många områden som utbildning, träning, etc.
• Programvaran Agent First: Ett enormt potentiellt användningsfall för AI-agenter är i utvecklingen av agentens första programvara. Istället för att manuellt bläddra och klicka på knappar för att få saker gjorda, kommer AI-agenter att utföra dem automatiskt baserat på röstkommandon.
• Rymd dator: När AR/VR-tekniken utvecklas kommer AI-agenter att spela en avgörande roll för att överbrygga klyftan mellan den virtuella och verkliga världen.

Slutsats

Vi är fortfarande i de tidiga stadierna av AI-agentutveckling. För närvarande, för bästa möjliga resultat från AI-agenter, måste vi lita på GPT-4, och det är dyrt. Men eftersom modellerna med öppen källkod kommer ikapp GPT-4 kommer vi att få bättre alternativ för att köra AI-agenter effektivt till en rimlig kostnad. Å andra sidan går ramarna för agentutveckling snabbt framåt. När vi går framåt kommer ramverken att göra det möjligt för agenter att utföra ännu mer komplexa uppgifter.

 Key Takeaways

• AI-agenter utnyttjar LLM:ers resonemangskapacitet för att välja lämpliga verktyg för att utföra komplexa uppgifter.
• CrewAI är ett ramverk med öppen källkod för att bygga samarbetande AI-agenter.
• Den unika egenskapen hos CrewAI inkluderar rollbaserade agenter, autonom delegering mellan agenter och flexibel uppgiftshantering.
• CrewAI integreras sömlöst med det befintliga Langchain-ekosystemet. Vi kan använda Langchain-verktyg och LLM-integrationer med CrewAI.

Vanliga frågor

Medierna som visas i den här artikeln ägs inte av Analytics Vidhya och används efter författarens gottfinnande.

Relaterad

• SEO-drivet innehåll och PR-distribution. Bli förstärkt idag.
• PlatoData.Network Vertical Generative Ai. Styrka dig själv. Tillgång här.
• PlatoAiStream. Web3 Intelligence. Kunskap förstärkt. Tillgång här.
• Platoesg. Kol, CleanTech, Energi, Miljö, Sol, Avfallshantering. Tillgång här.
• PlatoHealth. Biotech och kliniska prövningar Intelligence. Tillgång här.
• Källa: https://www.analyticsvidhya.com/blog/2024/01/building-collaborative-ai-agents-with-crewai/