Langchain vs Crewai gegen Autogen zum Aufbau eines Datenanalysemittels

In der heutigen datengesteuerten Welt verlassen sich Unternehmen auf Datenanalysten, um komplexe Datensätze zu interpretieren, umsetzbare Erkenntnisse aufzudecken und Entscheidungen zu fördern. Aber was wäre, wenn wir die Effizienz und Skalierbarkeit dieses Prozesses mit AI verbessern könnten? Geben Sie den Datenanalyse -Agenten ein, um Analyseaufgaben zu automatisieren, Code auszuführen und auf Datenabfragen adaptiv zu reagieren. Langgraph, Crewai und Autogen sind drei beliebte Rahmenbedingungen, die zum Aufbau von AI -Agenten verwendet werden. Wir werden alle drei in diesem Artikel verwenden und vergleichen, um einen einfachen Datenanalyse -Agenten zu erstellen.

Inhaltsverzeichnis

• Arbeiten des Datenanalyseagenten
• Erstellen eines Datenanalyseagenten mit Langgraph
  • Voraussetzungen
• Schritte zum Erstellen eines Datenanalyse -Agenten mit Langgraph
  • 1. Importieren Sie die erforderlichen Bibliotheken.
  • 2. Lassen Sie uns den Staat definieren.
  • 3. Definieren Sie die Funktion LLM und die Codeausführungsfunktion und binden Sie die Funktion an die LLM.
  • 4. Definieren Sie die Funktion, damit der Agent die Antwort als Knoten zum Diagramm hinzufügen kann.
  • 5. Definieren Sie den Toolnode und fügen Sie ihn dem Diagramm hinzu.
  • 6. Lassen Sie uns auch den Speicher hinzufügen, damit wir mit dem Agenten chatten können.
  • 7. Kompilieren und anzeigen Sie die Grafik.
  • 8. Jetzt können wir den Chat beginnen. Da wir Speicher hinzugefügt haben, geben wir jeder Konversation einen eindeutigen Thread_id und beginnen die Konversation in diesem Thread.
• Aufbau eines Datenanalyseagenten mit Crewai
  • 1. Importieren Sie die erforderlichen Bibliotheken.
  • 2. Wir erstellen einen Agenten, um den Code und einen anderen für die Ausführung dieses Codes zu generieren.
  • 3. Um den Code auszuführen, werden wir Pythonrepl () verwenden. Definieren Sie es als Crewai -Tool.
  • V.
  • 5. Bauen Sie die Besatzung mit beiden Agenten und entsprechenden Aufgaben.
  • 6. Führen Sie die Besatzung mit den folgenden Eingaben aus.
• Erstellen eines Datenanalysemittels mit Autogen
  • 1. Importieren Sie die erforderlichen Bibliotheken.
  • 2. Definieren Sie den Code -Executor und einen Agenten, um den Code Executor zu verwenden.
  • 3. Definieren Sie einen Agenten, um den Code mit einer benutzerdefinierten Systemnachricht zu schreiben.
  • 4. Definieren Sie das Problem, um den Chat zu lösen und zu initiieren.
  • 5. Wir können auch die Fragen, die uns und ihre Antworten bei Bedarf mit diesem Code gestellt haben.
• Langgraph gegen Crewai gegen Autogen
• Häufig gestellte Fragen

Arbeiten des Datenanalyseagenten

Der Datenanalyse -Agent nimmt zunächst die Abfrage vom Benutzer ab und generiert den Code, um die Datei zu lesen und die Daten in der Datei zu analysieren. Anschließend wird der generierte Code mit dem Python Reply -Tool ausgeführt. Das Ergebnis des Code wird an den Agenten zurückgesendet. Der Agent analysiert dann das aus dem Code ausgeführte Tool und antwortet auf die Benutzerabfrage. LLMs können beliebigen Code generieren, daher müssen wir den LLM-erzeugten Code in einer lokalen Umgebung sorgfältig ausführen.

Erstellen eines Datenanalyseagenten mit Langgraph

Wenn Sie in diesem Thema neu sind oder Ihr Wissen über Langgraph auffrischen möchten, würde ich hier einen Artikel empfehlen: Was ist Langgraph?

Voraussetzungen

Stellen Sie vor dem Bau von Agenten sicher, dass Sie über die erforderlichen API -Schlüssel für die erforderlichen LLMs verfügen.

Laden Sie die .EnV -Datei mit den benötigten API -Schlüssel.

 aus dotenv import load_dotenv

load_dotenv (./ env)

Wichtige Bibliotheken erforderlich

Langchain - 0.3.7

Langchain-experimental-0,3,3

Langgraph - 0.2.52

Crewai - 0,80,0

Crewai-Tools-0,14,0

Autogen-Agentchat-0,2,38

Jetzt, wo wir alle eingestellt sind, beginnen wir mit dem Aufbau unseres Agenten.

Schritte zum Erstellen eines Datenanalyse -Agenten mit Langgraph

1. Importieren Sie die erforderlichen Bibliotheken.

 Pandas als PD importieren
Aus Ipython.display -Importbild, Anzeige
Aus dem Einteichen importieren, wörtlich, optional, typedDict, kommentiert
aus Langchain_core.tools Import -Tool
von Langchain_core.Messages Import ToolMessage
von Langchain_experimental.utilities importieren pythonrepl
aus Langchain_openai importieren Sie Chatopenai
von Langgraph.graph import stategraph, starten, beenden
von Langgraph.graph.message import add_messages
von Langgraph.Prebuilt -Import -Toolnode, Tools_Condition
von Langgraph.Checkpoint.Memory Import MemorySeaver

2. Lassen Sie uns den Staat definieren.

 Klassenstatus (TypedDict):
	Nachrichten: Annotated [Liste, add_messages]
Graph_builder = stategraph (Zustand)

3. Definieren Sie die Funktion LLM und die Codeausführungsfunktion und binden Sie die Funktion an die LLM.

 llm = chatopenai (model = "gpt-4o-mini", Temperatur = 0,1)

@Werkzeug
Def Python_REPL (Code: Annotated [STR, Dateiname zum Lesen des Codes von "]):
    "" "Verwenden Sie dies, um den aus einer Datei gelesenen Python -Code auszuführen. Wenn Sie die Ausgabe eines Wertes sehen möchten,
    Stellen Sie sicher, dass Sie den Code korrekt aus lesen
    Sie sollten es mit "Print (...) ausdrucken. Dies ist für den Benutzer sichtbar. "" ""

    versuchen:
        Ergebnis = pythonrepl (). Run (Code)
        print ("Ergebniscodeausführung:", Ergebnis)
    außer baseexception als e:
        return f "versäumte auszuführen. Fehler: {repr (e)}"
    return f "ausgeführt: \ n```@python \ n {code} \ n`` \ nstdout: {result}"

llm_with_tools = llm.bind_tools ([python_repl])

4. Definieren Sie die Funktion, damit der Agent die Antwort als Knoten zum Diagramm hinzufügen kann.

 Def Chatbot (Zustand: Zustand):
    Rückgabe {"Nachrichten": [llm_with_tools.invoke (Status ["Nachrichten"]]]]}
    
Graph_builder.add_node ("Agent", Chatbot)

5. Definieren Sie den Toolnode und fügen Sie ihn dem Diagramm hinzu.

 code_execution = tolnode (Tools = [python_repl])

Graph_builder.add_node ("Tools", code_execution)

Wenn der LLM einen Tool -Anruf zurückgibt, müssen wir ihn an den Werkzeugknoten weiterleiten. Ansonsten können wir es beenden. Lassen Sie uns eine Funktion zum Routing definieren. Dann können wir andere Kanten hinzufügen.

 Def Route_tools (Zustand: Zustand,):
    "" "
    Verwenden Sie in der Conditional_Edge, um bei der letzten Meldung zum Toolnode zu leiten
    hat Toolsanrufe. Ansonsten Weg zum Ende.
    "" "
    Wenn Issinstance (Zustand, Liste):
        ai_message = Zustand [-1]
    ELIF -Nachrichten: = State.get ("Nachrichten", []):
        ai_message = messages [-1]
    anders:
        ValueError erhöhen (f "Keine Nachrichten im Eingabestatus zu Tool_Edge: {Status}")
    Wenn Hasattr (ai_message, "tool_calls") und len (ai_message.tool_calls)> 0:
        Rückgabe "Tools"
    Rücklauf
    
graph_builder.add_conditional_edges (
    "Agent",
    Route_tools,
    {"Tools": "Tools", Ende: Ende},
)

Graph_builder.add_Edge ("Tools", "Agent")

6. Lassen Sie uns auch den Speicher hinzufügen, damit wir mit dem Agenten chatten können.

 memory = meenSeSaver ()

Graph = graph_builder.comPile (pechPointer = Speicher)

7. Kompilieren und anzeigen Sie die Grafik.

 Graph = graph_builder.comPile (pechPointer = Speicher)

display (image (graph.get_graph (). Draw_mermaid_png ())))

8. Jetzt können wir den Chat beginnen. Da wir Speicher hinzugefügt haben, geben wir jeder Konversation einen eindeutigen Thread_id und beginnen die Konversation in diesem Thread.

 config = {"Konfigurierbar": {"thread_id": "1"}}

Def Stream_Graph_updates (user_input: str):
    Ereignisse = graph.stream (
        {"Nachrichten": [("Benutzer", user_input)]}, config, Stream_mode = "Werte"
    )
    Für Veranstaltungen in Veranstaltungen:
        Ereignis ["Nachrichten"] [-1] .pretty_print ()
        
während wahr:
    user_input = input ("Benutzer:")
    Wenn user_input.lower () in ["Quit", "Beenden", "Q"]:
        print ("Auf Wiedersehen!")
        brechen
    stream_graph_updates (user_input)

Während der Loop der Schleife geben wir zunächst den Pfad der Datei an und stellen dann Fragen anhand der Daten.

Die Ausgabe ist wie folgt:

Da wir Speicher aufgenommen haben, können wir alle Fragen im Datensatz im Chat stellen. Der Agent generiert den erforderlichen Code und der Code wird ausgeführt. Das Ergebnis der Codeausführung wird an die LLM zurückgesandt. Ein Beispiel ist unten gezeigt:

Lesen Sie auch: So erstellen Sie Ihren personalisierten Nachrichten Digest Agent mit Langgraph

Aufbau eines Datenanalyseagenten mit Crewai

Jetzt werden wir Crewai für die Datenanalyse -Aufgabe verwenden.

1. Importieren Sie die erforderlichen Bibliotheken.

 von Crewai Importagenten, Aufgabe, Crew
aus Crewai.tools Import -Tool
Aus Crewai_Tools Import DirectoryReadtool, Filereadtool
von Langchain_experimental.utilities importieren pythonrepl

2. Wir erstellen einen Agenten, um den Code und einen anderen für die Ausführung dieses Codes zu generieren.

 coding_agent = Agent (Agent (
	Rolle = "Python Developer",
	Ziel = "Bastern Sie gut gestaltete und durchdachte Code, um das gegebene Problem zu beantworten",
	Backstory = "" "Sie sind ein hochrangiger Python -Entwickler mit umfassender Erfahrung in der Software und seinen Best Practices.
            	Sie haben Fachkenntnisse beim Schreiben von sauberem, effizientem und skalierbarem Code. "" ",
	llm = 'gpt-4o',
	human_input = true,
)
coding_task = task (task (
	Beschreibung = "" "Schreiben Sie Code, um das angegebene Problem zu beantworten
                	Weisen Sie die Codeausgabe der Variablen "Ergebnis" zu
                    	Problem: {Problem},
                    	"" ",
	erwartet_output = "Code, um das Ergebnis für das Problem zu erhalten. Ausgabe des Code sollte der 'Ergebnis' Variablen zugewiesen werden",
	Agent = coding_agent
)

3. Um den Code auszuführen, werden wir Pythonrepl () verwenden. Definieren Sie es als Crewai -Tool.

 @tool ("repl")
Def repl (Code: str) -> str:
	"" Nützlich für die Ausführung von Python -Code "" "
	RECHTEN SIE PYTHONREPL ().

V.

 Executing_agent = Agent (Agent (
	Rolle = "Python Executor",
	Ziel = "Führen Sie den empfangenen Code aus, um das angegebene Problem zu beantworten",
	Backstory = "" "Sie sind ein Python -Entwickler mit umfangreicher Erfahrung in der Software und seinen Best Practices.
            	"Sie können Code ausführen, debuggen und Python -Lösungen effektiv optimieren." "",
	llm = 'gpt-4o-mini',
	human_input = true,
	Tools = [repl, fileReadtool ()]
)
Ausführung_task = Task (Task (Task (
	Beschreibung = "" "Führen Sie den Code aus, um das angegebene Problem zu beantworten
                	Weisen Sie die Codeausgabe der Variablen "Ergebnis" zu
                    	Problem: {Problem},
                    	"" ",
	erwartet_output = 'Das Ergebnis für das Problem',
	Agent = executing_agent
)

5. Bauen Sie die Besatzung mit beiden Agenten und entsprechenden Aufgaben.

 Analysis_Crew = Crew (
	Agents = [coding_agent, ausführend_agent],
	tasks = [coding_task, executing_task],
	wörtlich = wahr
)

6. Führen Sie die Besatzung mit den folgenden Eingaben aus.

 inputs = {'Problem': "" Lesen Sie diese Datei und geben Sie die Spaltennamen zurück und finden Sie das Durchschnittsalter
   "/home/santhosh/projects/code/langgraph/gym_members_exercise_tracking.csv" "",}

result = Analysis_crew.kickoff (Eingaben = Eingänge)

print (result.raw)

So wird die Ausgabe aussehen:

Lesen Sie auch: Bauen Sie LLM -Agenten im laufenden Fliegen ohne Code mit Crewai auf

Erstellen eines Datenanalysemittels mit Autogen

1. Importieren Sie die erforderlichen Bibliotheken.

 vom Autoogenimport ConversableAgent
von autogen.codieren lokalcommandLineCodeexexexecutor, DockerCommandLineCodeexexecutor

2. Definieren Sie den Code -Executor und einen Agenten, um den Code Executor zu verwenden.

 Executor = LocalcommandLineCodeExexecutor (
	Timeout = 10, # Timeout für jede Codeausführung in Sekunden.
	work_dir = './data', # Verwenden Sie das Verzeichnis, um die Codedateien zu speichern.
)
code_executor_agent = ConversableAg (
	"code_executor_agent",
	llm_config = false,
	code_execution_config = {"Executor": Executor},
	human_input_mode = "immer",
)

3. Definieren Sie einen Agenten, um den Code mit einer benutzerdefinierten Systemnachricht zu schreiben.

Nehmen Sie die CODE_WRITER-SYSTEM-Nachricht von https://microsoft.github.io/autogen/0.2/docs/tutorial/code-executors/.

code_writer_agent = ConversableAgent (
    "code_writer_agent",
    system_message = code_writer_system_message,
    llm_config = {"config_list": [{"modell": "gpt-4o-mini"}]},
    code_execution_config = false,
)

4. Definieren Sie das Problem, um den Chat zu lösen und zu initiieren.

 problem = "" "Lesen Sie die Datei auf dem Pfad
        	und drucken mittleres Alter der Menschen. "" "

chat_result = code_executor_agent.initiate_chat (
	code_writer_agent,
	Nachricht = Problem,
)

Sobald der Chat beginnt, können wir auch nachfolgende Fragen zum oben genannten Datensatz stellen. Wenn der Code auf Fehler auftritt, können wir fragen, um den Code zu ändern. Wenn der Code in Ordnung ist, können wir einfach "Eingabetaste" drücken, um den Code weiter auszuführen.

5. Wir können auch die Fragen, die uns und ihre Antworten bei Bedarf mit diesem Code gestellt haben.

 Für die Nachricht in chat_result.chat_history:
    Wenn Nachricht ['Rolle'] == 'Assistant':
        Wenn 'exitCode' nicht in Message ['Inhalt']]:
            print (message ['content'])
            print ('\ n')
            
    anders:
        Wenn 'in Message [' Inhalt 'enden']:        
            print (message ['content'])
            drucken("----------------------------------------")

Hier ist das Ergebnis:

Lesen Sie auch: Praktische Anleitung zum Aufbau von Chatbots mit Multi-Agent-Chatbots mit Autogen

Langgraph gegen Crewai gegen Autogen

Nachdem Sie gelernt haben, einen Datenanalyse -Agenten mit allen 3 Frameworks zu erstellen, lassen Sie uns die Unterschiede zwischen ihnen bei der Codeausführung untersuchen:

Rahmen	Schlüsselmerkmale	Stärken	Am besten geeignet für
Langgraph	-Graph-basierte Struktur (Knoten repräsentieren Agenten/Tools, Kanten definieren Wechselwirkungen) - nahtlose Integration in Pythonrepl	-hoch flexibel zum Erstellen strukturierter, mehrstufiger Workflows - sichere und effiziente Codeausführung mit Speicherkonservierung über die Aufgaben hinweg hinweg	Komplexe, prozessgetriebene Analysebereich, die klare, anpassbare Workflows erfordern
Crewai	-Zusammenarbeit ausgerichtet - mehrere Agenten, die parallel zu vordefinierten Rollen arbeiten - Integriert sich in Langchain -Werkzeuge	-aufgabenorientiertes Design - Ausgezeichnet für Teamarbeit und Rollenspezialisierung - Unterstützt eine sichere und zuverlässige Codeausführung mit Pythonrepl	Kollaborative Datenanalyse, Code-Review-Setups, Aufgabenabbau und rollenbasierte Ausführung
Autogen	- Dynamische und iterative Codeausführung - Conversable Agents für interaktive Ausführung und Debugging -integrierte Chat-Funktion	- adaptive und konverselle Workflows - Konzentrieren Sie sich auf dynamische Interaktion und Debugging - Ideal für schnelle Prototypen und Fehlerbehebung	Schnelle Prototyping, Fehlerbehebung und Umgebungen, in denen sich häufig Aufgaben und Anforderungen entwickeln

Abschluss

In diesem Artikel haben wir gezeigt, wie Datenanalyse -Agenten mit Langgraph, Crewai und Autogen erstellt werden. Mit diesen Frameworks können Agenten Code generieren, ausführen und analysieren, um Datenabfragen effizient zu beheben. Durch die Automatisierung von Wiederholungsaufgaben machen diese Tools die Datenanalyse schneller und skalierbarer. Das modulare Design ermöglicht die Anpassung für bestimmte Anforderungen und macht sie für Datenfachleute wertvoll. Diese Agenten zeigen das Potenzial von KI, Workflows zu vereinfachen und Erkenntnisse aus Daten problemlos zu extrahieren.

Um mehr über AI -Agenten zu erfahren, sehen Sie sich unser exklusives Agent -AI -Pionierprogramm an!

Häufig gestellte Fragen

Q1. Was sind die wichtigsten Vorteile der Verwendung von AI -Frameworks wie Langgraph, Crewai und Autogen für die Datenanalyse?

A. Diese Frameworks automatisieren die Codegenerierung und -ausführung und ermöglichen eine schnellere Datenverarbeitung und Erkenntnisse. Sie optimieren Workflows, reduzieren den manuellen Aufwand und verbessern die Produktivität für datengesteuerte Aufgaben.

Q2. Können diese Datenanalyse -Agenten mehrere Datensätze oder komplexe Abfragen verarbeiten?

A. Ja, die Agenten können so angepasst werden, dass verschiedene Datensätze und komplexe analytische Abfragen verarbeitet werden, indem geeignete Tools integriert und deren Workflows angepasst werden.

Q3. Welche Vorsichtsmaßnahmen sollten bei der Ausführung von LLM-generierten Code getroffen werden?

A. LLM erzeugter Code kann Fehler oder unsichere Operationen enthalten. Validieren Sie den Code immer in einer kontrollierten Umgebung, um die Genauigkeit und Sicherheit vor der Ausführung zu gewährleisten.

Q4. Wie verstärkt die Speicherintegration diese Datenanalyseagenten?

A. Speicherintegration ermöglicht es Agenten, den Kontext früherer Interaktionen zu behalten, wodurch adaptive Reaktionen und Kontinuität in komplexen oder mehrstufigen Abfragen ermöglicht werden.

Q5. Welche Arten von Aufgaben können diese Datenanalyse -Agenten automatisieren?

A. Diese Agenten können Aufgaben wie das Lesen von Dateien, die Durchführung von Datenreinigung, das Generieren von Zusammenfassungen, das Ausführen statistischer Analysen und die Beantwortung von Benutzeranfragen zu den Daten automatisieren.

Das obige ist der detaillierte Inhalt vonLangchain vs Crewai gegen Autogen zum Aufbau eines Datenanalysemittels. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!