Budowanie współpracujących agentów AI za pomocą CrewAI

Wprowadzenie

Rozwój agentów AI to jeden z najgorętszych obszarów innowacji w oprogramowaniu. Wraz z ewolucją jakości modeli wielkojęzykowych będziemy świadkami gwałtownego wzrostu integracji agentów AI z istniejącymi systemami oprogramowania. Dzięki agentom AI możliwe będzie wykonywanie zadań za pomocą poleceń głosowych lub gestów, zamiast ręcznego poruszania się po aplikacjach. Jednak obecnie rozwój agentów jest w początkowej fazie. Wciąż przechodzimy przez początkową fazę rozwoju infrastruktury, narzędzi i frameworków, podobnie jak Internet z lat 1990-tych. Dlatego w tym artykule omówimy inny framework do tworzenia agentów, zwany CrewAI.

Cele kształcenia

• Dowiedz się o agentach AI.
• Poznaj CrewAI – narzędzie typu open source dla agentów budowlanych.
• Zbuduj współpracującą załogę AI do pisania treści.
• Poznaj rzeczywiste przypadki użycia agentów AI.

Ten artykuł został opublikowany jako część Blogathon nauki o danych.

Kim są agenci AI?

Modele językowe wyróżniają się tłumaczeniem, podsumowywaniem i rozumowaniem. Jednak można z nimi wiele zrobić. Jednym ze sposobów pełnego wykorzystania potencjału rozumowania jest uczynienie LLM agentycznymi. Agenci AI to LLM wzmocnione odpowiednimi narzędziami i podpowiedziami. Agenci ci mogą automatyzować przeglądanie, usuwanie stron internetowych, wykonywanie zapytań SQL, operacje na plikach i nie tylko. Agenci wykorzystują zdolność rozumowania LLM, aby wybrać narzędzie w oparciu o bieżące wymagania. Zamiast jednak używać jednego agenta do wykonania zadania, możemy połączyć wielu z nich w celu wykonania złożonych zadań.

Langchain to domyślne narzędzie, które przychodzi na myśl przy omawianiu agentów AI. Jednak ręczne organizowanie agentów AI w celu wykonywania wspólnych zadań byłoby w przypadku Langchain wyzwaniem. Tutaj właśnie pojawia się CrewAI.

Co to jest CrewAI?

ZałogaAI to platforma typu open source do koordynowania odgrywania ról i autonomicznych agentów AI. Pomaga tworzyć współpracujących agentów AI, aby z łatwością osiągać złożone cele. Platforma została zaprojektowana tak, aby umożliwić agentom AI przyjmowanie ról, delegowanie zadań i dzielenie się celami, podobnie jak załoga w świecie rzeczywistym. Oto niektóre z unikalnych cech CrewAI:

• Agenci bazujący na rolach: możemy zdefiniować agentów z określonymi rolami, celami i historią, aby zapewnić LLM większy kontekst przed wygenerowaniem odpowiedzi.
• Zarządzanie zadaniami: definiuj zadania za pomocą narzędzi i dynamicznie przydzielaj je agentom.
• Delegowanie między agentami: agenci mogą delegować zadania innym agentom, aby efektywnie współpracować.

Poniżej znajduje się reprezentacja mapy myśli CrewAI.

CrewAI płynnie integruje się z ekosystemem Langchain. Oznacza to, że możemy korzystać z narzędzi Langchain i integracji LLM z CrewAI. 

Budowanie współpracującej załogi AI

Aby lepiej zrozumieć CrewAI, zbudujmy współpracujących agentów AI do kreatywnego pisania treści. W tym celu zdefiniujemy agentów, narzędzia i odpowiednie zadania dla każdego agenta. Ponieważ jest to zespół zajmujący się pisaniem treści, zdefiniujemy trzech odrębnych agentów, takich jak analityk pomysłów, pisarz i redaktor. Każdemu agentowi zostanie przydzielone zadanie.

Agent analityk będzie odpowiedzialny za analizę pomysłu i przygotowanie kompleksowego planu napisania treści. Agent Autora przygotuje wersję roboczą artykułu, a na koniec redaktor będzie odpowiedzialny za formatowanie, edycję i poprawianie wersji roboczej. Jak wiemy, CrewAI pozwala nam wzbogacać agentów o niestandardowe narzędzia. Rozszerzymy edytor o narzędzie umożliwiające zapisanie go na dysku lokalnym. Ale aby osiągnąć te wszystkie rzeczy, potrzebujemy LLM. Tutaj użyjemy modelu Gemini firmy Google.

Zagłębmy się w kodowanie

Podobnie jak w przypadku każdego projektu w języku Python, utwórz środowisko wirtualne i zainstaluj zależności. Będziemy potrzebować biblioteki Crewai i implementacji Langchaina Google GenAI. Możesz używać innych LLM, takich jak modele o otwartym dostępie z Razem, Dowolna skalalub modele OpenAI.

pip install crewai langchain-google-genai

Następnym krokiem jest zdefiniowanie naszego LLM i agentów współpracujących. Utwórz osobny plik o nazwie agents.py, aby zdefiniować agentów.

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
           )

Zdefiniujmy narzędzie do zapisywania plików.

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

Powyższa metoda write_file jest ozdobiona funkcją narzędziową Langchaina. Ponieważ CrewAI wykorzystuje Langchain pod maską, narzędzia muszą być zgodne z konwencjami Langchain. Funkcja oczekuje pojedynczego ciągu znaków składającego się z dwóch części, ścieżki pliku i treści oddzielonych kreską (|). Ciągi dokumentów metody są również używane jako dodatkowy kontekst dla funkcji. Dlatego pamiętaj o podaniu szczegółowych informacji na temat metody.

Zdefiniujmy agentów

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
)

Mamy trzech agentów, każdy z inną rolą, celem i historią. Informacje te służą jako zachęta dla LLM do nadania szerszego kontekstu. Z agentem redaktora powiązane jest narzędzie do pisania.

Następną rzeczą jest zdefiniowanie zadań. W tym celu utwórz inny plik 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).
            """)

Zadania zawarte w tym miejscu to szczegółowe plany działania, których wykonania oczekujesz od agentów.

Na koniec utwórz plik main.py, w którym montujemy Agentów i Zadania, aby stworzyć funkcjonalną załogę.

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

W powyższym kodzie zdefiniowaliśmy klasę ContentWritingCrew, która akceptuje ciąg pomysłów od użytkownika. Metoda _create_tasks tworzy zadania. Metoda __call__ inicjuje i uruchamia załogę. Po uruchomieniu skryptu możesz obserwować łańcuch działań na terminalu lub notatniku. Zadania będą realizowane w kolejności ustalonej przez załogę. Oto migawka dziennika wykonania.

To jest dziennik wykonania końcowego agenta. czyli redaktor. Edytuje wersję roboczą otrzymaną od agenta autora i używa narzędzia do zapisywania plików, aby zapisać plik pod odpowiednią nazwą.

Jest to ogólny proces tworzenia współpracujących agentów AI za pomocą CrewAI. Możesz sparować inne narzędzia Langchain lub stworzyć własne narzędzia z efektywnym podpowiedzią, aby wykonać bardziej złożone zadania.

Oto repozytorium GitHub z kodami: sunilkumardash9/ContentWritingAgents.

Repozytorium replik: Sunil-KumarKu17/ColborativeAIAgent

Przypadki użycia w świecie rzeczywistym

Autonomiczni agenci AI mogą mieć wiele zastosowań. Od osobistych asystentów po wirtualnych instruktorów. Oto kilka przypadków użycia agentów AI.

• Osobisty asystent AI: Osobiści asystenci wkrótce będą naszą integralną częścią. Asystent podobny do Jarvisa, który przetwarza wszystkie Twoje dane, zapewnia wgląd w Twoją pracę i samodzielnie radzi sobie z trywialnymi zadaniami.
• Interpretatory kodu: Interpreter kodu OpenAI jest doskonałym przykładem agenta AI. Interpreter może uruchomić dowolny skrypt Pythona i wyświetlić wyniki w odpowiedzi na monit tekstowy. Jest to prawdopodobnie najskuteczniejszy agent w historii.
• Wirtualni instruktorzy: W miarę ewolucji technologii sztucznej inteligencji możemy spodziewać się wirtualnych instruktorów w wielu dziedzinach, takich jak edukacja, szkolenia itp.
• Oprogramowanie Agent First: Ogromny potencjalny przypadek użycia agentów AI dotyczy tworzenia oprogramowania najpierw przez agenta. Zamiast ręcznie przeglądać i klikać przyciski, aby wykonać zadania, agenci AI automatycznie wykonają je na podstawie poleceń głosowych.
• Obliczenia przestrzenne: W miarę ewolucji technologii AR/VR agenci sztucznej inteligencji będą odgrywać kluczową rolę w wypełnianiu luki między światem wirtualnym i rzeczywistym.

Wnioski

Wciąż jesteśmy na wczesnym etapie rozwoju agenta AI. Obecnie, aby uzyskać najlepsze możliwe wyniki działania agentów AI, musimy polegać na GPT-4, a jest to kosztowne. Jednak w miarę jak modele open source dogonią GPT-4, otrzymamy lepsze opcje wydajnego uruchamiania agentów AI przy rozsądnych kosztach. Z drugiej strony ramy rozwoju agentów postępują szybko. W miarę postępów struktury umożliwią agentom wykonywanie jeszcze bardziej złożonych zadań.

 Na wynos

• Agenci AI wykorzystują zdolność rozumowania LLM do wybierania odpowiednich narzędzi do realizacji złożonych zadań.
• CrewAI to platforma typu open source do tworzenia współpracujących agentów AI.
• Unikalna funkcja CrewAI obejmuje agentów opartych na rolach, autonomiczne delegowanie między agentami i elastyczne zarządzanie zadaniami.
• CrewAI płynnie integruje się z istniejącym ekosystemem Langchain. Możemy wykorzystać narzędzia Langchain i integracje LLM z CrewAI.

Często Zadawane Pytania

Media pokazane w tym artykule nie są własnością Analytics Vidhya i są wykorzystywane według uznania Autora.

Związane z

• Dystrybucja treści i PR oparta na SEO. Uzyskaj wzmocnienie już dziś.
• PlatoData.Network Pionowe generatywne AI. Wzmocnij się. Dostęp tutaj.
• PlatoAiStream. Inteligencja Web3. Wiedza wzmocniona. Dostęp tutaj.
• PlatonESG. Węgiel Czysta technologia, Energia, Środowisko, Słoneczny, Gospodarowanie odpadami. Dostęp tutaj.
• Platon Zdrowie. Inteligencja w zakresie biotechnologii i badań klinicznych. Dostęp tutaj.
• Źródło: https://www.analyticsvidhya.com/blog/2024/01/building-collaborative-ai-agents-with-crewai/