swarms

Der produktionsbereite Multi-Agent-Orchestrierungsrahmen für Unternehmensgrade

? Twitter • ? Zwietracht • Schwärme Plattform • ? Dokumentation

Merkmale

Kategorie	Merkmale	Vorteile
? Enterprise Architecture	• Produktionsbereitete Infrastruktur • hohe Zuverlässigkeitssysteme • Modulares Design • Umfassende Protokollierung	• Reduzierte Ausfallzeiten • Einfachere Wartung • Besseres Debuggen • Verbesserte Überwachung
? Agent Orchestrierung	• Hierarchische Schwärme • Parallele Verarbeitung • Sequentielle Workflows • Grafische Workflows • Umlagerung der dynamischen Agenten	• Komplexe Aufgabenbehandlung • Verbesserte Leistung • Flexible Workflows • Optimierte Ausführung
Integrationsfähigkeiten	• Support für Multimodell • Custom Agent -Erstellung • Umfangreiche Werkzeugbibliothek • Mehrere Speichersysteme	• Flexibilität der Anbieter • Benutzerdefinierte Lösungen • Erweiterte Funktionalität • Verbesserte Speicherverwaltung
? Skalierbarkeit	• Gleichzeitige Verarbeitung • Ressourcenmanagement • Lastausgleich • Horizontale Skalierung	• höherer Durchsatz • Effiziente Ressourcenverwendung • Bessere Leistung • Einfach Skalierung
Entwicklerwerkzeuge	• Einfache API • Umfangreiche Dokumentation • aktive Gemeinschaft • CLI -Werkzeuge	• schnellere Entwicklung • Einfache Lernkurve • Unterstützung der Gemeinschaft • Schnelle Bereitstellung
? Sicherheitsfunktionen	• Fehlerbehandlung • Ratenbegrenzung • Überwachung der Integration • Protokollierung prüfen	• Verbesserte Zuverlässigkeit • API -Schutz • Bessere Überwachung • Verbesserte Verfolgung
Erweiterte Funktionen	• Tabelle • Gruppenchat • Agentenregister • Mischung von Agenten	• Massenagentenmanagement • Kollaborative KI • Zentralisierte Kontrolle • Komplexe Lösungen
? Anbieterunterstützung	• Openai • Anthropisch • Chromadb • Sonderanbieter	• Flexibilität der Anbieter • Speicheroptionen • Benutzerdefinierte Integration • Anbieterunabhängigkeit
? Produktionsmerkmale	• Automatische Wiederholungen • Asynchronisierungsunterstützung • Umweltmanagement • Geben Sie Sicherheit ein	• Bessere Zuverlässigkeit • Verbesserte Leistung • Einfache Konfiguration • Sicherer Code
Anwendungsfallunterstützung	• Aufgabenspezifische Agenten • Benutzerdefinierte Workflows • Branchenlösungen • Erweiterbarer Rahmen	• Schnelle Bereitstellung • Flexible Lösungen • Branchenbereitschaft • Einfache Anpassung

---

Anforderungen

• python3.10 oder höher!
• $ pip install -U swarms und nicht vergessen, Schwärme zu installieren!
• .env -Datei mit API -Schlüssel von Ihren Anbietern wie OPENAI_API_KEY , ANTHROPIC_API_KEY
• Setzen Sie eine .env -Variable export WORKSPACE_DIR="agent_workspace" Ihrem WORKSPACE_DIR="agent_workspace" Arbeitsbereich.
• Schließlich swarms onboarding um Ihnen den Einstieg zu erleichtern.

Guides und Walkthroughs

In unserer Dokumentation finden Sie Informationen zur Implementierung von Produktionsklassen.

Abschnitt	Links
Installation	Installation
QuickStart	Fangen an
Interne Mechanismen des Agenten	Agentenarchitektur
Agent -API	Agent -API
Integration von externen Wirkstoffen Griptape, Autogen usw.	Integration externer APIs
Schaffung von Agenten aus Yaml	Schaffung von Agenten aus Yaml
Warum Sie Schwärme brauchen	Warum eine multiierende Zusammenarbeit notwendig ist
Analyse der Schwarmarchitekturen	Schwarmarchitekturen
Wählen Sie den richtigen Schwarm für Ihr Geschäftsproblem aus	KLICKEN SIE HIER
AgentreReRange Docs	KLICKEN SIE HIER

Installieren

$ pip3 install -U swarms

Onboarding

Nachdem Sie Schwärme mit pip3 install -U swarms heruntergeladen haben, erhalten wir Zugriff auf die CLI . Machen Sie sich jetzt mit CLI mit:

swarms onboarding

Sie können diesen Befehl auch für Hilfe ausführen:

swarms help

Weitere Dokumentationen über die CLI finden Sie hier

---

Nutzungsbeispiele?

Hier sind einige Beispielskripte, die Ihnen den Einstieg erleichtern. Weitere umfassendere Unterlagen finden Sie in unseren Dokumenten.

Beispielname	Beschreibung	Art der Beispiele	Link
Schwärme Beispiele	Eine Sammlung einfacher Beispiele zur Demonstration von Schwärmen.	Grundnutzung	https://github.com/the-swarm-corporation/swarms-examples?tab=readme-ov-file
Kochbuch	Ein umfassender Leitfaden mit Rezepten für verschiedene Anwendungsfälle und Szenarien.	Erweiterte Verwendung	https://github.com/the-swarm-corporation/cookbook

---

Agent

Die Agent ist eine grundlegende Komponente des Swarms -Frameworks, mit denen Aufgaben autonom ausgeführt werden sollen. Es verbindet LLMs, Tools und Langzeitgedächtnisfunktionen, um einen vollständigen Stack-Agenten zu erstellen. Die Agent ist sehr anpassbar und ermöglicht eine feinkörnige Kontrolle über ihr Verhalten und ihre Interaktionen.

Methode run

Die run ist der primäre Einstiegspunkt für die Ausführung von Aufgaben mit einer Agent . Es akzeptiert eine Task -Zeichenfolge als Haupteingabedask und verarbeitet sie gemäß der Konfiguration des Agenten. Und es kann auch einen img -Parameter wie img="image_filepath.png akzeptieren, um Bilder zu verarbeiten

Einstellungen und Anpassung

Die Agent -Klasse bietet eine Reihe von Einstellungen, um ihr Verhalten auf bestimmte Bedürfnisse anzupassen. Einige wichtige Einstellungen umfassen:

Einstellung	Beschreibung	Standardwert
agent_name	Der Name des Agenten.	"DefaultAgent"
system_prompt	Die Systemaufforderung für den Agenten.	"Standardsystem Eingabeaufforderung."
llm	Das Sprachmodell, das für Verarbeitungsaufgaben verwendet werden soll.	OpenAIChat -Instanz
max_loops	Die maximale Anzahl von Schleifen, die für eine Aufgabe ausgeführt werden sollen.	1
autosave	Aktiviert oder deaktiviert das Autosaving des Agentenstaates.	FALSCH
dashboard	Aktiviert oder deaktiviert das Dashboard für den Agenten.	FALSCH
verbose	Steuert die Ausführlichkeit der Ausgabe des Agenten.	FALSCH
dynamic_temperature_enabled	Aktiviert oder deaktiviert dynamische Temperaturanpassung für das Sprachmodell.	FALSCH
saved_state_path	Der Weg, um den Status des Agenten zu retten.	"Agent_State.json"
user_name	Der mit dem Agent verbundene Benutzername.	"default_user"
retry_attempts	Die Anzahl der Wiederholungsversuche für fehlgeschlagene Aufgaben.	1
context_length	Die maximale Länge des Kontextes für Aufgaben.	200000
return_step_meta	Steuert, ob die Metadaten der Stufe im Ausgang zurückgegeben werden sollen.	FALSCH
output_type	Die Art der Ausgabe, die zurückgibt (z. B. "JSON", "String").	"String"

 import os
from swarms import Agent
from swarm_models import OpenAIChat

from swarms . prompts . finance_agent_sys_prompt import (
    FINANCIAL_AGENT_SYS_PROMPT ,
)
from dotenv import load_dotenv

load_dotenv ()

# Get the OpenAI API key from the environment variable
api_key = os . getenv ( "OPENAI_API_KEY" )

# Create an instance of the OpenAIChat class
model = OpenAIChat (
    openai_api_key = api_key , model_name = "gpt-4o-mini" , temperature = 0.1
)

# Initialize the agent
agent = Agent (
    agent_name = "Financial-Analysis-Agent" ,
    system_prompt = FINANCIAL_AGENT_SYS_PROMPT ,
    llm = model ,
    max_loops = 1 ,
    autosave = True ,
    dashboard = False ,
    verbose = True ,
    dynamic_temperature_enabled = True ,
    saved_state_path = "finance_agent.json" ,
    user_name = "swarms_corp" ,
    retry_attempts = 1 ,
    context_length = 200000 ,
    return_step_meta = False ,
    output_type = "string" ,
    streaming_on = False ,
)


agent . run (
    "How can I establish a ROTH IRA to buy stocks and get a tax break? What are the criteria"
)

---

Integration von Lappen mit Schwärmen für einen verbesserten Langzeitgedächtnis

Mit quasi infinitiver Langzeitspeicher ausgestattetes Agent unter Verwendung von RAG (Relational Agent Graph) für erweiterte Dokumentenverständnis-, Analyse- und Abruffunktionen.

Meerjungfrau -Diagramm zur Integration von Lappen

 Graph TD
    Ein [Initialisieren von Agent mit LAG] -> B [Aufgabe empfangen]
    B-> C [Langzeitgedächtnis abfragen]
    C -> D [Prozessaufgabe mit Kontext]
    D -> E [Antwort erzeugen]
    E-> f [Aktualisieren Sie den Langzeitgedächtnis]
    F -> g [Rückgabeausgabe]

Schritt 1: Initialisieren Sie den Chromadb -Client

 import os

from swarms_memory import ChromaDB

# Initialize the ChromaDB client for long-term memory management
chromadb = ChromaDB (
    metric = "cosine" ,  # Metric for similarity measurement
    output_dir = "finance_agent_rag" ,  # Directory for storing RAG data
    # docs_folder="artifacts",  # Uncomment and specify the folder containing your documents
)

Schritt 2: Definieren Sie das Modell

 from swarm_models import Anthropic
from swarms . prompts . finance_agent_sys_prompt import (
    FINANCIAL_AGENT_SYS_PROMPT ,
)

# Define the Anthropic model for language processing
model = Anthropic ( anthropic_api_key = os . getenv ( "ANTHROPIC_API_KEY" ))

Schritt 3: Initialisieren Sie den Agenten mit LAG

 from swarms import Agent

# Initialize the agent with RAG capabilities
agent = Agent (
    agent_name = "Financial-Analysis-Agent" ,
    system_prompt = FINANCIAL_AGENT_SYS_PROMPT ,
    agent_description = "Agent creates a comprehensive financial analysis" ,
    llm = model ,
    max_loops = "auto" ,  # Auto-adjusts loops based on task complexity
    autosave = True ,  # Automatically saves agent state
    dashboard = False ,  # Disables dashboard for this example
    verbose = True ,  # Enables verbose mode for detailed output
    streaming_on = True ,  # Enables streaming for real-time processing
    dynamic_temperature_enabled = True ,  # Dynamically adjusts temperature for optimal performance
    saved_state_path = "finance_agent.json" ,  # Path to save agent state
    user_name = "swarms_corp" ,  # User name for the agent
    retry_attempts = 3 ,  # Number of retry attempts for failed tasks
    context_length = 200000 ,  # Maximum length of the context to consider
    long_term_memory = chromadb ,  # Integrates ChromaDB for long-term memory management
    return_step_meta = False ,
    output_type = "string" ,
)

# Run the agent with a sample task
agent . run (
    "What are the components of a startups stock incentive equity plan"
)

---

Verschiedene Agenteneinstellungen

Wir bieten eine Vielzahl von Funktionen, mit denen Agent -Zustände mit JSON, YAML, TOML, PDFs, gegründeten Jobs und vielem mehr hochgeladen werden können!

Methode Tabelle

Verfahren	Beschreibung
to_dict()	Konvertiert das Agentenobjekt in ein Wörterbuch.
to_toml()	Konvertiert das Agentenobjekt in eine TOML -Zeichenfolge.
model_dump_json()	Entlastet das Modell in eine JSON -Datei.
model_dump_yaml()	Entlastet das Modell in eine YAML -Datei.
ingest_docs()	Nehmen Sie Dokumente in die Wissensbasis des Agenten ein.
receive_message()	Empfängt eine Nachricht von einem Benutzer und verarbeitet sie.
send_agent_message()	Sendet eine Nachricht vom Agenten an einen Benutzer.
filtered_run()	Führt den Agenten mit einer gefilterten Systemaufforderung aus.
bulk_run()	Führt den Agenten mit mehreren Systemanforderungen aus.
add_memory()	Fügt dem Agenten einen Speicher hinzu.
check_available_tokens()	Überprüft die Anzahl der verfügbaren Token für den Agenten.
tokens_checks()	Führt Token -Schecks für den Agenten durch.
print_dashboard()	Druckt das Dashboard des Agenten.
get_docs_from_doc_folders()	Ruft alle Dokumente aus den DOC -Ordnern ab.
activate_agentops()	Aktiviert Agentenoperationen.
check_end_session_agentops()	Überprüft das Ende der Sitzung auf Agentenoperationen.

 # # Convert the agent object to a dictionary
print ( agent . to_dict ())
print ( agent . to_toml ())
print ( agent . model_dump_json ())
print ( agent . model_dump_yaml ())

# Ingest documents into the agent's knowledge base
agent . ingest_docs ( "your_pdf_path.pdf" )

# Receive a message from a user and process it
agent . receive_message ( name = "agent_name" , message = "message" )

# Send a message from the agent to a user
agent . send_agent_message ( agent_name = "agent_name" , message = "message" )

# Ingest multiple documents into the agent's knowledge base
agent . ingest_docs ( "your_pdf_path.pdf" , "your_csv_path.csv" )

# Run the agent with a filtered system prompt
agent . filtered_run (
    "How can I establish a ROTH IRA to buy stocks and get a tax break? What are the criteria?"
)

# Run the agent with multiple system prompts
agent . bulk_run (
    [
        "How can I establish a ROTH IRA to buy stocks and get a tax break? What are the criteria?" ,
        "Another system prompt" ,
    ]
)

# Add a memory to the agent
agent . add_memory ( "Add a memory to the agent" )

# Check the number of available tokens for the agent
agent . check_available_tokens ()

# Perform token checks for the agent
agent . tokens_checks ()

# Print the dashboard of the agent
agent . print_dashboard ()

# Fetch all the documents from the doc folders
agent . get_docs_from_doc_folders ()

# Activate agent ops
agent . activate_agentops ()
agent . check_end_session_agentops ()

# Dump the model to a JSON file
agent . model_dump_json ()
print ( agent . to_toml ())

Agent mit pydantischem Basemodel als Ausgangstyp

Das Folgende ist ein Beispiel für einen Agenten, der ein pydantisches Basemodel aufnimmt und gleichzeitig ausgibt:

 from pydantic import BaseModel , Field
from swarms import Agent
from swarm_models import Anthropic


# Initialize the schema for the person's information
class Schema ( BaseModel ):
    name : str = Field (..., title = "Name of the person" )
    agent : int = Field (..., title = "Age of the person" )
    is_student : bool = Field (..., title = "Whether the person is a student" )
    courses : list [ str ] = Field (
        ..., title = "List of courses the person is taking"
    )


# Convert the schema to a JSON string
tool_schema = Schema (
    name = "Tool Name" ,
    agent = 1 ,
    is_student = True ,
    courses = [ "Course1" , "Course2" ],
)

# Define the task to generate a person's information
task = "Generate a person's information based on the following schema:"

# Initialize the agent
agent = Agent (
    agent_name = "Person Information Generator" ,
    system_prompt = (
        "Generate a person's information based on the following schema:"
    ),
    # Set the tool schema to the JSON string -- this is the key difference
    tool_schema = tool_schema ,
    llm = Anthropic (),
    max_loops = 3 ,
    autosave = True ,
    dashboard = False ,
    streaming_on = True ,
    verbose = True ,
    interactive = True ,
    # Set the output type to the tool schema which is a BaseModel
    output_type = tool_schema ,  # or dict, or str
    metadata_output_type = "json" ,
    # List of schemas that the agent can handle
    list_base_models = [ tool_schema ],
    function_calling_format_type = "OpenAI" ,
    function_calling_type = "json" ,  # or soon yaml
)

# Run the agent to generate the person's information
generated_data = agent . run ( task )

# Print the generated data
print ( f"Generated data: { generated_data } " )

Multi -Modal Autonomous Agent

Führen Sie den Agenten mit mehreren Modalitäten aus, die für verschiedene reale Aufgaben in der Fertigung, Logistik und Gesundheit nützlich sind.

 import os
from dotenv import load_dotenv
from swarms import Agent

from swarm_models import GPT4VisionAPI

# Load the environment variables
load_dotenv ()


# Initialize the language model
llm = GPT4VisionAPI (
    openai_api_key = os . environ . get ( "OPENAI_API_KEY" ),
    max_tokens = 500 ,
)

# Initialize the task
task = (
    "Analyze this image of an assembly line and identify any issues such as"
    " misaligned parts, defects, or deviations from the standard assembly"
    " process. IF there is anything unsafe in the image, explain why it is"
    " unsafe and how it could be improved."
)
img = "assembly_line.jpg"

## Initialize the workflow
agent = Agent (
    agent_name = "Multi-ModalAgent" ,
    llm = llm , 
    max_loops = "auto" , 
    autosave = True , 
    dashboard = True , 
    multi_modal = True
)

# Run the workflow on a task
agent . run ( task , img )

---

ToolAgent

Toolagent ist ein Agent, der Tools über JSON -Funktionsaufruf verwenden kann. Es nimmt jedes Open -Source -Modell von Suggingface auf und ist extrem modular und steckt ein und spielt. Wir brauchen bald Hilfe bei der allgemeinen Unterstützung für alle Modelle.

 from pydantic import BaseModel , Field
from transformers import AutoModelForCausalLM , AutoTokenizer

from swarms import ToolAgent
from swarms . utils . json_utils import base_model_to_json

# Load the pre-trained model and tokenizer
model = AutoModelForCausalLM . from_pretrained (
    "databricks/dolly-v2-12b" ,
    load_in_4bit = True ,
    device_map = "auto" ,
)
tokenizer = AutoTokenizer . from_pretrained ( "databricks/dolly-v2-12b" )


# Initialize the schema for the person's information
class Schema ( BaseModel ):
    name : str = Field (..., title = "Name of the person" )
    agent : int = Field (..., title = "Age of the person" )
    is_student : bool = Field (
        ..., title = "Whether the person is a student"
    )
    courses : list [ str ] = Field (
        ..., title = "List of courses the person is taking"
    )


# Convert the schema to a JSON string
tool_schema = base_model_to_json ( Schema )

# Define the task to generate a person's information
task = (
    "Generate a person's information based on the following schema:"
)

# Create an instance of the ToolAgent class
agent = ToolAgent (
    name = "dolly-function-agent" ,
    description = "Ana gent to create a child data" ,
    model = model ,
    tokenizer = tokenizer ,
    json_schema = tool_schema ,
)

# Run the agent to generate the person's information
generated_data = agent . run ( task )

# Print the generated data
print ( f"Generated data: { generated_data } " )

Integration externer Agenten

Die Integration von externen Agenten aus anderen Agent -Frameworks ist bei Schwärmen einfach.

Schritte:

1. Erstellen Sie eine neue Klasse, die Agent erbt
2. Erstellen Sie eine .run(task: str) -> str -Methode, die den Agenten ausführt und die Antwort zurückgibt.
3. Der neue Agent muss eine Zeichenfolge der Antwort zurückgeben. Sie können jedoch zusätzliche Methoden hinzufügen, um die Ausgabe an JSON zu speichern.

Griptape -Beispiel

Hier finden Sie beispielsweise ein Beispiel, wie Sie einen Agenten aus Griptape erstellen.

So können Sie ein benutzerdefiniertes Griptape -Agent erstellen, das sich in das Swarms -Framework integriert, indem Sie von der Agent in Schwärmen erben und die run(task: str) -> str -Methode überschreiben.

 from swarms import (
    Agent as SwarmsAgent ,
)  # Import the base Agent class from Swarms
from griptape . structures import Agent as GriptapeAgent
from griptape . tools import (
    WebScraperTool ,
    FileManagerTool ,
    PromptSummaryTool ,
)


# Create a custom agent class that inherits from SwarmsAgent
class GriptapeSwarmsAgent ( SwarmsAgent ):
    def __init__ ( self , * args , ** kwargs ):
        # Initialize the Griptape agent with its tools
        self . agent = GriptapeAgent (
            input = "Load {{ args[0] }}, summarize it, and store it in a file called {{ args[1] }}." ,
            tools = [
                WebScraperTool ( off_prompt = True ),
                PromptSummaryTool ( off_prompt = True ),
                FileManagerTool (),
            ],
            * args ,
            ** kwargs ,
            # Add additional settings
        )

    # Override the run method to take a task and execute it using the Griptape agent
    def run ( self , task : str ) -> str :
        # Extract URL and filename from task (you can modify this parsing based on task structure)
        url , filename = task . split (
            ","
        )  # Example of splitting task string
        # Execute the Griptape agent with the task inputs
        result = self . agent . run ( url . strip (), filename . strip ())
        # Return the final result as a string
        return str ( result )


# Example usage:
griptape_swarms_agent = GriptapeSwarmsAgent ()
output = griptape_swarms_agent . run (
    "https://griptape.ai, griptape.txt"
)
print ( output )

Schlüsselkomponenten:

1. GriptapesWarmsAgent : Eine benutzerdefinierte Klasse, die aus der SwarmsAgent -Klasse erbt und den Griptape -Agenten integriert.
2. Ausführen (Aufgabe: STR) -> STR : Eine Methode, die eine Task -Zeichenfolge annimmt, sie verarbeitet (z. B. in eine URL und einen Dateinamen) und den Griptape -Agenten mit den bereitgestellten Eingaben ausführt.
3. Griptape -Tools : Die in den Griptape Agent (z. B. WebScraperTool , PromptSummaryTool , FileManagerTool ) integrierten Tools ermöglichen Web -Scraping, Summarization und Dateiverwaltung.

Sie können diesen benutzerdefinierten Griptape -Agenten jetzt einfach in das Swarms -Framework anschließen und es verwenden, um Aufgaben auszuführen!

Schwärme verstehen

Was ist ein Schwarm?

Ein Schwarm bezieht sich auf eine Gruppe von mehr als zwei Agenten, die gemeinsam ein gemeinsames Ziel erreichen. Diese Agenten können Softwareentitäten wie LLMs sein, die miteinander interagieren, um komplexe Aufgaben auszuführen. Das Konzept eines Schwarms ist von natürlichen Systemen wie Ameisenkolonien oder Vogelherden inspiriert, bei denen einfache individuelle Verhaltensweisen zu komplexen Gruppendynamik und Problemlösungsfähigkeiten führen.

Wie Schwarmarchitekturen die Kommunikation erleichtern

Schwarmarchitekturen sollen die Kommunikation zwischen Agenten innerhalb eines Schwarms aufbauen und verwalten. Diese Architekturen definieren, wie Agenten interagieren, Informationen austauschen und ihre Aktionen koordinieren, um die gewünschten Ergebnisse zu erzielen. Hier sind einige wichtige Aspekte der Schwarmarchitekturen:

1. Hierarchische Kommunikation : In hierarchischen Schwärmen fließt Kommunikationsflüsse von Agenten auf höherer Ebene bis hin zu Agenten der unteren Ebene. Aufstrebende Agenten fungieren als Koordinatoren, verteilen Aufgaben und aggregierende Ergebnisse. Diese Struktur ist effizient für Aufgaben, die die Steuerung und Entscheidungsfindung erfordern.

2. Parallele Kommunikation : In parallelen Schwärmen arbeiten Agenten unabhängig und kommunizieren bei Bedarf miteinander. Diese Architektur eignet sich für Aufgaben, die gleichzeitig ohne Abhängigkeiten verarbeitet werden können, was eine schnellere Ausführung und Skalierbarkeit ermöglicht.

3. Sequentielle Kommunikation : Sequentielle Schwärme Prozessaufgaben in einer linearen Reihenfolge, wobei die Ausgabe jedes Agenten zur Eingabe für den nächsten Agenten wird. Dies stellt sicher, dass Aufgaben mit Abhängigkeiten in der richtigen Reihenfolge behandelt werden, wodurch die Integrität des Workflows aufrechterhalten wird.

4. Netzkommunikation : In Mesh -Schwärmen sind Agenten vollständig verbunden, sodass jeder Agent mit jedem anderen Agenten kommunizieren kann. Dieses Setup bietet eine hohe Flexibilität und Redundanz und ist so ideal für komplexe Systeme, die dynamische Wechselwirkungen erfordern.

5. Federated Communication : Federated Swarms beinhalten mehrere unabhängige Schwärme, die zusammenarbeiten, indem sie Informationen und Ergebnisse weitergeben. Jeder Schwarm arbeitet autonom, kann jedoch zu einer größeren Aufgabe beitragen, wodurch eine verteilte Problemlösung über verschiedene Knoten hinweg ermöglicht wird.

Schwarmarchitekturen nutzen diese Kommunikationsmuster, um sicherzustellen, dass Agenten effizient zusammenarbeiten und sich an die spezifischen Anforderungen der jeweiligen Aufgabe anpassen. Durch die Definition klarer Kommunikationsprotokolle und Interaktionsmodelle ermöglichen Schwarmarchitekturen die nahtlose Orchestrierung mehrerer Wirkstoffe, was zu einer verbesserten Leistung und Problemlösungsfunktionen führt.

Name	Beschreibung	Code -Link	Anwendungsfälle
Hierarchische Schwärme	Ein System, in dem Agenten in einer Hierarchie organisiert sind und Agenten über höhere Ebenen koordinieren, um komplexe Aufgaben zu erreichen.	Code -Link	Herstellungsprozessoptimierung, mehrstufiges Vertriebsmanagement, Koordination von Gesundheitsressourcen
Agent neu ordnen	Ein Setup, bei dem sich die Agenten dynamisch basierend auf den Aufgabenanforderungen und den Umgebungsbedingungen neu ordnen.	Code -Link	Adaptive Fertigungslinien, dynamische Verkaufsgebiet neu ausgerichtet, flexibles Gesundheitswesen
Gleichzeitige Workflows	Agenten führen gleichzeitig unterschiedliche Aufgaben aus und koordinieren, um ein größeres Ziel zu erreichen.	Code -Link	Gleichzeitige Produktionslinien, parallele Vertriebsabläufe, gleichzeitige Patientenversorgungsprozesse
Sequentielle Koordination	Wirkstoffe führen Aufgaben in einer bestimmten Sequenz aus, bei der die Fertigstellung einer Aufgabe den Beginn des nächsten aus auslöst.	Code -Link	Schritt-für-Schritt-Montage-Linien, sequentielle Verkaufsprozesse, schrittweise Patientenbehandlungsworkflows
Parallele Verarbeitung	Agenten arbeiten gleichzeitig an verschiedenen Teilen einer Aufgabe, um den Gesamtprozess zu beschleunigen.	Code -Link	Parallele Datenverarbeitung in der Herstellung, gleichzeitige Verkaufsanalyse, gleichzeitige medizinische Tests
Mischung von Agenten	Ein heterogener Schwarm, bei dem Agenten mit unterschiedlichen Fähigkeiten kombiniert werden, um komplexe Probleme zu lösen.	Code -Link	Finanzielle Prognose, komplexe Problemlösung, die unterschiedliche Fähigkeiten erfordern
Graph Workflow	Agenten arbeiten in einem DAG -Format (Criture Acyclic Graph) zusammen, um Abhängigkeiten und parallele Aufgaben zu verwalten.	Code -Link	KI-gesteuerte Softwareentwicklungspipelines, komplexes Projektmanagement
Gruppenchat	Agenten betreiben eine chat-ähnliche Interaktion, um Entscheidungen gemeinsam zu treffen.	Code -Link	Echtzeit kollaborative Entscheidungsfindung, Vertragsverhandlungen
Agentenregister	Ein zentrales Register, in dem Agenten gespeichert, abgerufen und dynamisch aufgerufen werden.	Code -Link	Dynamic Agent Management, sich entwickelnde Empfehlungsmotoren
Tabelle Schwarm	Verwaltet Aufgaben im Maßstab und verfolgt Agent die Ausgaben in einem strukturierten Format wie CSV -Dateien.	Code -Link	Großmän den Marketinganalysen, Finanzprüfungen
Waldschwarm	Eine Schwarmstruktur, die Agenten in einer baumartigen Hierarchie für komplexe Entscheidungsprozesse organisiert.	Code -Link	Mehrstufige Workflows, hierarchisches Verstärkungslernen
Schwarmrouter	Routen und wählt die Schwarmarchitektur basierend auf den Aufgabenanforderungen und den verfügbaren Agenten aus.	Code -Link	Dynamische Aufgabenrouting, adaptive Swarmarchitekturauswahl, optimierte Agentenzuweisung

SequentialWorkflow

Mit dem sequenziellen Workflow können Sie Aufgaben mit Agent nacheinander ausführen und die Ausgabe an den nächsten Agenten übergeben, bis Sie Ihre maximalen Loops angegeben haben.

 Graph LR
    A [Agent 1] -> B [Agent 2]
    B -> C [Agent 3]
    C -> D [Agent 4]
    D -> E [Max Loops]
    E -> f [Ende]

Methoden

Verfahren	Beschreibung	Parameter	Rückgabewert
__init__	Initialisieren Sie den sequentiellen Workflow	agents : Liste der Agentenobjekte max_loops : maximale Anzahl von Iterationen verbose : Boolean für die ausführliche Ausgabe	Keiner
run	Führen Sie den Workflow aus	input_data : Erste Eingabe für den ersten Agenten	Endgültige Ausgabe, nachdem alle Agenten verarbeitet wurden

Eingänge

Eingang	Typ	Beschreibung
agents	Liste [Agent]	Liste der Agentenobjekte, die nacheinander ausgeführt werden sollen
max_loops	int	Die maximale Häufigkeit der gesamten Sequenz wird wiederholt
verbose	bool	Wenn wahr, drucken Sie detaillierte Informationen während der Ausführung detailliert

Ausgabe

Die run -Methode gibt die endgültige Ausgabe zurück, nachdem alle Agenten die Eingabe nacheinander verarbeitet haben.

In diesem Beispiel repräsentiert jeder Agent eine nacheinander ausgeführte Aufgabe. Die Ausgabe eines jeden Agenten wird in der Sequenz an den nächsten Agenten übergeben, bis die maximale Anzahl von Schleifen erreicht ist. Dieser Workflow ist besonders nützlich für Aufgaben, bei denen eine Reihe von Schritten in einer bestimmten Reihenfolge ausgeführt werden muss, z. B. Pipelines für Datenverarbeitung oder komplexe Berechnungen, die auf der Ausgabe früherer Schritte beruhen.

 import os
from swarms import Agent , SequentialWorkflow
from swarm_models import OpenAIChat

# model = Anthropic(anthropic_api_key=os.getenv("ANTHROPIC_API_KEY"))
company = "Nvidia"
# Get the OpenAI API key from the environment variable
api_key = os . getenv ( "GROQ_API_KEY" )

# Model
model = OpenAIChat (
    openai_api_base = "https://api.groq.com/openai/v1" ,
    openai_api_key = api_key ,
    model_name = "llama-3.1-70b-versatile" ,
    temperature = 0.1 ,
)


# Initialize the Managing Director agent
managing_director = Agent (
    agent_name = "Managing-Director" ,
    system_prompt = f"""
    As the Managing Director at Blackstone, your role is to oversee the entire investment analysis process for potential acquisitions. 
    Your responsibilities include:
    1. Setting the overall strategy and direction for the analysis
    2. Coordinating the efforts of the various team members and ensuring a comprehensive evaluation
    3. Reviewing the findings and recommendations from each team member
    4. Making the final decision on whether to proceed with the acquisition
    
    For the current potential acquisition of { company } , direct the tasks for the team to thoroughly analyze all aspects of the company, including its financials, industry position, technology, market potential, and regulatory compliance. Provide guidance and feedback as needed to ensure a rigorous and unbiased assessment.
    """ ,
    llm = model ,
    max_loops = 1 ,
    dashboard = False ,
    streaming_on = True ,
    verbose = True ,
    stopping_token = "<DONE>" ,
    state_save_file_type = "json" ,
    saved_state_path = "managing-director.json" ,
)

# Initialize the Vice President of Finance
vp_finance = Agent (
    agent_name = "VP-Finance" ,
    system_prompt = f"""
    As the Vice President of Finance at Blackstone, your role is to lead the financial analysis of potential acquisitions. 
    For the current potential acquisition of { company } , your tasks include:
    1. Conducting a thorough review of { company } ' financial statements, including income statements, balance sheets, and cash flow statements
    2. Analyzing key financial metrics such as revenue growth, profitability margins, liquidity ratios, and debt levels
    3. Assessing the company's historical financial performance and projecting future performance based on assumptions and market conditions
    4. Identifying any financial risks or red flags that could impact the acquisition decision
    5. Providing a detailed report on your findings and recommendations to the Managing Director

    Be sure to consider factors such as the sustainability of { company } ' business model, the strength of its customer base, and its ability to generate consistent cash flows. Your analysis should be data-driven, objective, and aligned with Blackstone's investment criteria.
    """ ,
    llm = model ,
    max_loops = 1 ,
    dashboard = False ,
    streaming_on = True ,
    verbose = True ,
    stopping_token = "<DONE>" ,
    state_save_file_type = "json" ,
    saved_state_path = "vp-finance.json" ,
)

# Initialize the Industry Analyst
industry_analyst = Agent (
    agent_name = "Industry-Analyst" ,
    system_prompt = f"""
    As the Industry Analyst at Blackstone, your role is to provide in-depth research and analysis on the industries and markets relevant to potential acquisitions.
    For the current potential acquisition of { company } , your tasks include:
    1. Conducting a comprehensive analysis of the industrial robotics and automation solutions industry, including market size, growth rates, key trends, and future prospects
    2. Identifying the major players in the industry and assessing their market share, competitive strengths and weaknesses, and strategic positioning 
    3. Evaluating { company } ' competitive position within the industry, including its market share, differentiation, and competitive advantages
    4. Analyzing the key drivers and restraints for the industry, such as technological advancements, labor costs, regulatory changes, and economic conditions
    5. Identifying potential risks and opportunities for { company } based on the industry analysis, such as disruptive technologies, emerging markets, or shifts in customer preferences  
    
    Your analysis should provide a clear and objective assessment of the attractiveness and future potential of the industrial robotics industry, as well as { company } ' positioning within it. Consider both short-term and long-term factors, and provide evidence-based insights to inform the investment decision.
    """ ,
    llm = model ,
    max_loops = 1 ,
    dashboard = False ,
    streaming_on = True ,
    verbose = True ,
    stopping_token = "<DONE>" ,
    state_save_file_type = "json" ,
    saved_state_path = "industry-analyst.json" ,
)

# Initialize the Technology Expert
tech_expert = Agent (
    agent_name = "Tech-Expert" ,
    system_prompt = f"""
    As the Technology Expert at Blackstone, your role is to assess the technological capabilities, competitive advantages, and potential risks of companies being considered for acquisition.
    For the current potential acquisition of { company } , your tasks include:
    1. Conducting a deep dive into { company } ' proprietary technologies, including its robotics platforms, automation software, and AI capabilities 
    2. Assessing the uniqueness, scalability, and defensibility of { company } ' technology stack and intellectual property
    3. Comparing { company } ' technologies to those of its competitors and identifying any key differentiators or technology gaps
    4. Evaluating { company } ' research and development capabilities, including its innovation pipeline, engineering talent, and R&D investments
    5. Identifying any potential technology risks or disruptive threats that could impact { company } ' long-term competitiveness, such as emerging technologies or expiring patents
    
    Your analysis should provide a comprehensive assessment of { company } ' technological strengths and weaknesses, as well as the sustainability of its competitive advantages. Consider both the current state of its technology and its future potential in light of industry trends and advancements.
    """ ,
    llm = model ,
    max_loops = 1 ,
    dashboard = False ,
    streaming_on = True ,
    verbose = True ,
    stopping_token = "<DONE>" ,
    state_save_file_type = "json" ,
    saved_state_path = "tech-expert.json" ,
)

# Initialize the Market Researcher
market_researcher = Agent (
    agent_name = "Market-Researcher" ,
    system_prompt = f"""
    As the Market Researcher at Blackstone, your role is to analyze the target company's customer base, market share, and growth potential to assess the commercial viability and attractiveness of the potential acquisition.
    For the current potential acquisition of { company } , your tasks include:
    1. Analyzing { company } ' current customer base, including customer segmentation, concentration risk, and retention rates
    2. Assessing { company } ' market share within its target markets and identifying key factors driving its market position
    3. Conducting a detailed market sizing and segmentation analysis for the industrial robotics and automation markets, including identifying high-growth segments and emerging opportunities
    4. Evaluating the demand drivers and sales cycles for { company } ' products and services, and identifying any potential risks or limitations to adoption
    5. Developing financial projections and estimates for { company } ' revenue growth potential based on the market analysis and assumptions around market share and penetration
    
    Your analysis should provide a data-driven assessment of the market opportunity for { company } and the feasibility of achieving our investment return targets. Consider both bottom-up and top-down market perspectives, and identify any key sensitivities or assumptions in your projections.
    """ ,
    llm = model ,
    max_loops = 1 ,
    dashboard = False ,
    streaming_on = True ,
    verbose = True ,
    stopping_token = "<DONE>" ,
    state_save_file_type = "json" ,
    saved_state_path = "market-researcher.json" ,
)

# Initialize the Regulatory Specialist
regulatory_specialist = Agent (
    agent_name = "Regulatory-Specialist" ,
    system_prompt = f"""
    As the Regulatory Specialist at Blackstone, your role is to identify and assess any regulatory risks, compliance requirements, and potential legal liabilities associated with potential acquisitions.
    For the current potential acquisition of { company } , your tasks include:  
    1. Identifying all relevant regulatory bodies and laws that govern the operations of { company } , including industry-specific regulations, labor laws, and environmental regulations
    2. Reviewing { company } ' current compliance policies, procedures, and track record to identify any potential gaps or areas of non-compliance
    3. Assessing the potential impact of any pending or proposed changes to relevant regulations that could affect { company } ' business or create additional compliance burdens
    4. Evaluating the potential legal liabilities and risks associated with { company } ' products, services, and operations, including product liability, intellectual property, and customer contracts
    5. Providing recommendations on any regulatory or legal due diligence steps that should be taken as part of the acquisition process, as well as any post-acquisition integration considerations
    
    Your analysis should provide a comprehensive assessment of the regulatory and legal landscape surrounding { company } , and identify any material risks or potential deal-breakers. Consider both the current state and future outlook, and provide practical recommendations to mitigate identified risks.
    """ ,
    llm = model ,
    max_loops = 1 ,
    dashboard = False ,
    streaming_on = True ,
    verbose = True ,
    stopping_token = "<DONE>" ,
    state_save_file_type = "json" ,
    saved_state_path = "regulatory-specialist.json" ,
)

# Create a list of agents
agents = [
    managing_director ,
    vp_finance ,
    industry_analyst ,
    tech_expert ,
    market_researcher ,
    regulatory_specialist ,
]


swarm = SequentialWorkflow (
    name = "blackstone-private-equity-advisors" ,
    agents = agents ,
)

print (
    swarm . run (
        "Analyze nvidia if it's a good deal to invest in now 10B"
    )
)

---

AgentRearrange

Mit der AgentRearrange Orchestration -Technik, die von Einops und Einsum inspiriert ist, können Sie die Beziehungen zwischen verschiedenen Wirkstoffen definieren und abbilden. Es bietet ein leistungsstarkes Werkzeug zum orchestrieren komplexen Workflows, sodass Sie lineare und sequentielle Beziehungen wie a -> a1 -> a2 -> a3 oder gleichzeitige Beziehungen angeben können, bei denen der erste Agent gleichzeitig eine Nachricht an 3 Agenten sendet: a -> a1, a2, a3 . Diese Anpassungsstufe ermöglicht die Erstellung hocheffizienter und dynamischer Workflows, bei denen Agenten bei Bedarf parallel oder nacheinander arbeiten können. Die AgentRearrange -Technik ist eine wertvolle Ergänzung der Swarms -Bibliothek und bietet ein neues Maß an Flexibilität und Kontrolle über die Orchestrierung von Agenten. Ausführlichere Informationen und Beispiele finden Sie in der offiziellen Dokumentation.

Methoden

Verfahren	Beschreibung	Parameter	Rückgabewert
__init__	Initialisieren Sie die AgentreReRange	agents : Liste der Agentenobjekte flow : String, der den Agentenfluss beschreibt	Keiner
run	Führen Sie den Workflow aus	input_data : Erste Eingabe für den ersten Agenten	Endgültige Ausgabe, nachdem alle Agenten verarbeitet wurden

Eingänge

Eingang	Typ	Beschreibung
agents	Liste [Agent]	Liste der orchestrierten Agentenobjekte
flow	str	Zeichenfolge, die den Fluss von Agenten beschreibt (z. B. "A -> B, C")

Ausgabe

Die run -Methode gibt die endgültige Ausgabe zurück, nachdem alle Agenten die Eingabe gemäß dem angegebenen Fluss verarbeitet haben.

 from swarms import Agent , AgentRearrange


from swarm_models import Anthropic

# Initialize the director agent

director = Agent (
    agent_name = "Director" ,
    system_prompt = "Directs the tasks for the workers" ,
    llm = Anthropic (),
    max_loops = 1 ,
    dashboard = False ,
    streaming_on = True ,
    verbose = True ,
    stopping_token = "<DONE>" ,
    state_save_file_type = "json" ,
    saved_state_path = "director.json" ,
)


# Initialize worker 1

worker1 = Agent (
    agent_name = "Worker1" ,
    system_prompt = "Generates a transcript for a youtube video on what swarms are" ,
    llm = Anthropic (),
    max_loops = 1 ,
    dashboard = False ,
    streaming_on = True ,
    verbose = True ,
    stopping_token = "<DONE>" ,
    state_save_file_type = "json" ,
    saved_state_path = "worker1.json" ,
)


# Initialize worker 2
worker2 = Agent (
    agent_name = "Worker2" ,
    system_prompt = "Summarizes the transcript generated by Worker1" ,
    llm = Anthropic (),
    max_loops = 1 ,
    dashboard = False ,
    streaming_on = True ,
    verbose = True ,
    stopping_token = "<DONE>" ,
    state_save_file_type = "json" ,
    saved_state_path = "worker2.json" ,
)


# Create a list of agents
agents = [ director , worker1 , worker2 ]

# Define the flow pattern
flow = "Director -> Worker1 -> Worker2"

# Using AgentRearrange class
agent_system = AgentRearrange ( agents = agents , flow = flow )
output = agent_system . run (
    "Create a format to express and communicate swarms of llms in a structured manner for youtube"
)
print ( output )

HierarhicalSwarm

Bald kommen ...

GraphSwarm

Das GraphSwarm ist ein Workflow -Management -System, mit dem komplexe Aufgaben orchestrieren können, indem die Kraft der Graphentheorie nutzt. Es ermöglicht die Erstellung eines gerichteten acyclischen Graphen (DAG), um Abhängigkeiten zwischen Aufgaben und Wirkstoffen zu modellieren. Dies ermöglicht eine effiziente Aufgabenzuweisung, Ausführung und Überwachung.

Hier ist eine Aufschlüsselung der Funktionsweise des GraphSwarm :

1. Knotenerstellung : Der GraphSwarm -Workflow besteht aus Knoten, die entweder Agenten oder Aufgaben sein können. Agenten sind für die Ausführung von Aufgaben verantwortlich, und Aufgaben stellen bestimmte Operationen dar, die ausgeführt werden müssen. Im Beispiel werden zwei Agenten ( agent1 und agent2 ) und eine Aufgabe ( task1 ) erstellt.
2. Randdefinition : Kanten werden verwendet, um die Beziehungen zwischen Knoten zu definieren. In diesem Fall werden Kanten erstellt, um agent1 und agent2 mit task1 zu verbinden, was darauf hinweist, dass beide Agenten in der Lage sind, task1 auszuführen.
3. Eintritts- und Endpunkte : Der GraphSwarm -Workflow erfordert die Definition von Einstiegspunkten (wo der Workflow beginnt) und Endpunkte (wo der Workflow abschließt). In diesem Beispiel werden agent1 und agent2 als Einstiegspunkte festgelegt und task1 als Endpunkt festgelegt.
4. Visualisierung : Das GraphSwarm bietet eine Visualisierungsfunktion, um den Workflow grafisch darzustellen. Dies ermöglicht das einfache Verständnis und das Debuggen der Workflow -Struktur.
5. Ausführung : Der GraphSwarm -Workflow wird ausgeführt, indem das Diagramm von den Einstiegspunkten bis zu den Endpunkten durchquert wird. In diesem Fall führen sowohl agent1 als auch agent2 task1 gleichzeitig aus, und die Ergebnisse werden gesammelt.
6. Ergebnisse : Die endgültigen Ergebnisse der Workflow -Ausführung werden aggregiert und zurückgegeben. In diesem Beispiel ist das Ergebnis der Ausführung von task1 "Aufgabe abgeschlossen".

Das GraphSwarm bietet mehrere Vorteile, darunter:

• Parallelität : Ermöglicht die Ausführung von Aufgaben gleichzeitig und verbessert die Effizienz des Gesamt -Workflows.
• Flexibilität : Ermöglicht eine dynamische Aufgabenzuweisung basierend auf der Verfügbarkeit der Agenten und der Aufgabenanforderungen.
• Skalierbarkeit : Unterstützt nach Bedarf neue Agenten und Aufgaben, wodurch sie für groß angelegte Workflows geeignet ist.
• Visualisierung : Bietet eine grafische Darstellung des Workflows, das Verständnis und Debuggen erleichtert.

Durch die Nutzung des GraphSwarm können komplexe Workflows effizient verwaltet werden und Aufgaben auf koordinierte und skalierbare Weise ausgeführt werden.

Methoden

Verfahren	Beschreibung	Parameter	Rückgabewert
add_node	Fügen Sie dem Diagramm einen Knoten hinzu	node : Knotenobjekt	Keiner
add_edge	Fügen Sie der Grafik eine Kante hinzu	edge : Kantenobjekt	Keiner
set_entry_points	Stellen Sie die Einstiegspunkte der Grafik ein	entry_points : Liste der Knoten -IDs	Keiner
set_end_points	Stellen Sie die Endpunkte der Grafik ein	end_points : Liste der Knoten -IDs	Keiner
visualize	Generieren Sie eine visuelle Darstellung des Diagramms	Keiner	String -Darstellung der Grafik
run	Führen Sie den Workflow aus	Keiner	Wörterbuch der Ausführungsergebnisse

Eingänge

Eingang	Typ	Beschreibung
Node	Objekt	Repräsentiert einen Knoten im Diagramm (Agent oder Aufgabe)
Edge	Objekt	Repräsentiert eine Kante, die zwei Knoten verbindet
entry_points	Liste [STR]	Liste der Knoten -IDs, bei denen der Workflow beginnt
end_points	Liste [STR]	Liste der Knoten -IDs, bei denen der Workflow endet

Ausgabe

Die run -Methode gibt ein Wörterbuch zurück, das die Ausführungsergebnisse aller Knoten im Diagramm enthält.

 import os

from dotenv import load_dotenv


from swarms import Agent , Edge , GraphWorkflow , Node , NodeType

from swarm_models import OpenAIChat

load_dotenv ()

api_key = os . environ . get ( "OPENAI_API_KEY" )

llm = OpenAIChat (
    temperature = 0.5 , openai_api_key = api_key , max_tokens = 4000
)
agent1 = Agent ( llm = llm , max_loops = 1 , autosave = True , dashboard = True )
agent2 = Agent ( llm = llm , max_loops = 1 , autosave = True , dashboard = True )

def sample_task ():
    print ( "Running sample task" )
    return "Task completed"

wf_graph = GraphWorkflow ()
wf_graph . add_node ( Node ( id = "agent1" , type = NodeType . AGENT , agent = agent1 ))
wf_graph . add_node ( Node ( id = "agent2" , type = NodeType . AGENT , agent = agent2 ))
wf_graph . add_node (
    Node ( id = "task1" , type = NodeType . TASK , callable = sample_task )
)
wf_graph . add_edge ( Edge ( source = "agent1" , target = "task1" ))
wf_graph . add_edge ( Edge ( source = "agent2" , target = "task1" ))

wf_graph . set_entry_points ([ "agent1" , "agent2" ])
wf_graph . set_end_points ([ "task1" ])

print ( wf_graph . visualize ())

# Run the workflow
results = wf_graph . run ()
print ( "Execution results:" , results )

MixtureOfAgents

Dies ist eine Implementierung, die auf dem Papier basiert: "Die Mischung der Agenten verbessert die Funktionen der großartigen Sprachmodells" von zusammen.ai, erhältlich unter https://arxiv.org/abs/2406.04692. Es erzielt hochmoderne Ergebnisse (SOTA) zu Alpacaeval 2.0, MT-Bench und Flask, wobei der GPT-4 Omni übertrifft. Diese Architektur eignet sich besonders für Aufgaben, die eine Parallelisierung erfordern, gefolgt von einer sequentiellen Verarbeitung in einer anderen Schleife.

Methoden

Verfahren	Beschreibung	Parameter	Rückgabewert
__init__	Initialisieren Sie die Mischung	name : Name des Schwarms agents : Liste der Agentenobjekte layers : Anzahl der Verarbeitungsschichten final_agent : Agent für die endgültige Verarbeitung	Keiner
run	Den Schwarm ausführen	task : Eingabeaufgabe für den Schwarm	Endgültige Ausgabe, nachdem alle Agenten verarbeitet wurden

Eingänge

Eingang	Typ	Beschreibung
name	str	Name des Schwarms
agents	Liste [Agent]	Liste der Agentenobjekte, die im Schwarm verwendet werden sollen
layers	int	Anzahl der Verarbeitungsschichten im Schwarm
final_agent	Agent	Agent, der für die endgültige Verarbeitung verantwortlich ist

Ausgabe

Die run -Methode gibt die endgültige Ausgabe zurück, nachdem alle Agenten die Eingabe gemäß den angegebenen Schichten und dem endgültigen Agenten verarbeitet haben.

 import os
from swarm_models import OpenAIChat
from swarms import Agent , MixtureOfAgents

api_key = os . getenv ( "OPENAI_API_KEY" )

# Create individual agents with the OpenAIChat model
model = OpenAIChat (
    openai_api_key = api_key , model_name = "gpt-4" , temperature = 0.1
)

# Agent 1: Financial Statement Analyzer
agent1 = Agent (
    agent_name = "FinancialStatementAnalyzer" ,
    llm = model ,
    system_prompt = """You are a Financial Statement Analyzer specializing in 10-K SEC reports. Your primary focus is on analyzing the financial statements, including the balance sheet, income statement, and cash flow statement. 

Key responsibilities:
1. Identify and explain significant changes in financial metrics year-over-year.
2. Calculate and interpret key financial ratios (e.g., liquidity ratios, profitability ratios, leverage ratios).
3. Analyze trends in revenue, expenses, and profitability.
4. Highlight any red flags or areas of concern in the financial statements.
5. Provide insights on the company's financial health and performance based on the data.

When analyzing, consider industry standards and compare the company's performance to its peers when possible. Your analysis should be thorough, data-driven, and provide actionable insights for investors and stakeholders.""" ,
    max_loops = 1 ,
    autosave = True ,
    dashboard = False ,
    verbose = True ,
    dynamic_temperature_enabled = True ,
    saved_state_path = "financial_statement_analyzer_state.json" ,
    user_name = "swarms_corp" ,
    retry_attempts = 1 ,
    context_length = 200000 ,
    return_step_meta = False ,
)

# Agent 2: Risk Assessment Specialist
agent2 = Agent (
    agent_name = "RiskAssessmentSpecialist" ,
    llm = model ,
    system_prompt = """You are a Risk Assessment Specialist focusing on 10-K SEC reports. Your primary role is to identify, analyze, and evaluate potential risks disclosed in the report.

Key responsibilities:
1. Thoroughly review the "Risk Factors" section of the 10-K report.
2. Identify and categorize different types of risks (e.g., operational, financial, legal, market, technological).
3. Assess the potential impact and likelihood of each identified risk.
4. Analyze the company's risk mitigation strategies and their effectiveness.
5. Identify any emerging risks not explicitly mentioned but implied by the company's operations or market conditions.
6. Compare the company's risk profile with industry peers when possible.

Your analysis should provide a comprehensive overview of the company's risk landscape, helping stakeholders understand the potential challenges and uncertainties facing the business. Be sure to highlight any critical risks that could significantly impact the company's future performance or viability.""" ,
    max_loops = 1 ,
    autosave = True ,
    dashboard = False ,
    verbose = True ,
    dynamic_temperature_enabled = True ,
    saved_state_path = "risk_assessment_specialist_state.json" ,
    user_name = "swarms_corp" ,
    retry_attempts = 1 ,
    context_length = 200000 ,
    return_step_meta = False ,
)

# Agent 3: Business Strategy Evaluator
agent3 = Agent (
    agent_name = "BusinessStrategyEvaluator" ,
    llm = model ,
    system_prompt = """You are a Business Strategy Evaluator specializing in analyzing 10-K SEC reports. Your focus is on assessing the company's overall strategy, market position, and future outlook.

Key responsibilities:
1. Analyze the company's business description, market opportunities, and competitive landscape.
2. Evaluate the company's products or services, including their market share and growth potential.
3. Assess the effectiveness of the company's current business strategy and its alignment with market trends.
4. Identify key performance indicators (KPIs) and evaluate the company's performance against these metrics.
5. Analyze management's discussion and analysis (MD&A) section to understand their perspective on the business.
6. Identify potential growth opportunities or areas for improvement in the company's strategy.
7. Compare the company's strategic position with key competitors in the industry.

Your analysis should provide insights into the company's strategic direction, its ability to create value, and its potential for future growth. Consider both short-term and long-term perspectives in your evaluation.""" ,
    max_loops = 1 ,
    autosave = True ,
    dashboard = False ,
    verbose = True ,
    dynamic_temperature_enabled = True ,
    saved_state_path = "business_strategy_evaluator_state.json" ,
    user_name = "swarms_corp" ,
    retry_attempts = 1 ,
    context_length = 200000 ,
    return_step_meta = False ,
)

# Aggregator Agent
aggregator_agent = Agent (
    agent_name = "10KReportAggregator" ,
    llm = model ,
    system_prompt = """You are the 10-K Report Aggregator, responsible for synthesizing and summarizing the analyses provided by the Financial Statement Analyzer, Risk Assessment Specialist, and Business Strategy Evaluator. Your goal is to create a comprehensive, coherent, and insightful summary of the 10-K SEC report.

Key responsibilities:
1. Integrate the financial analysis, risk assessment, and business strategy evaluation into a unified report.
2. Identify and highlight the most critical information and insights from each specialist's analysis.
3. Reconcile any conflicting information or interpretations among the specialists' reports.
4. Provide a balanced view of the company's overall performance, risks, and strategic position.
5. Summarize key findings and their potential implications for investors and stakeholders.
6. Identify any areas where further investigation or clarification may be needed.

Your final report should be well-structured, easy to understand, and provide a holistic view of the company based on the 10-K SEC report. It should offer valuable insights for decision-making while acknowledging any limitations or uncertainties in the analysis.""" ,
    max_loops = 1 ,
    autosave = True ,
    dashboard = False ,
    verbose = True ,
    dynamic_temperature_enabled = True ,
    saved_state_path = "10k_report_aggregator_state.json" ,
    user_name = "swarms_corp" ,
    retry_attempts = 1 ,
    context_length = 200000 ,
    return_step_meta = False ,
)

# Create the Mixture of Agents class
moa = MixtureOfAgents (
    agents = [ agent1 , agent2 , agent3 ],
    aggregator_agent = aggregator_agent ,
    aggregator_system_prompt = """As the 10-K Report Aggregator, your task is to synthesize the analyses provided by the Financial Statement Analyzer, Risk Assessment Specialist, and Business Strategy Evaluator into a comprehensive and coherent report. 

Follow these steps:
1. Review and summarize the key points from each specialist's analysis.
2. Identify common themes and insights across the analyses.
3. Highlight any discrepancies or conflicting interpretations, if present.
4. Provide a balanced and integrated view of the company's financial health, risks, and strategic position.
5. Summarize the most critical findings and their potential impact on investors and stakeholders.
6. Suggest areas for further investigation or monitoring, if applicable.

Your final output should be a well-structured, insightful report that offers a holistic view of the company based on the 10-K SEC report analysis.""" ,
    layers = 3 ,
)

# Example usage
company_name = "NVIDIA"
out = moa . run (
    f"Analyze the latest 10-K SEC report for { company_name } . Provide a comprehensive summary of the company's financial performance, risk profile, and business strategy."
)
print ( out )

Tabelle

Die SpreadSheetSwarm ist für das gleichzeitige Management und die Überwachung von Tausenden von Agenten ausgelegt, wodurch ein Eins-zu-viele-Ansatz für eine effiziente Aufgabenverarbeitung und -ausgangsanalyse ermöglicht wird.

Schlüsselmerkmale

• Parallelität : Ermöglicht die gleichzeitige Ausführung mehrerer Wirkstoffe, wodurch die Verarbeitungszeit erheblich verkürzt und die Effizienz des Gesamtsystems erhöht wird.
• Eins-zu-Many : Ermöglicht es einer einzelnen Aufgabe, unter mehreren Agenten dynamisch verteilt zu werden, um sicherzustellen, dass jeder Agent für sein volles Potenzial ausgewählt wird.
• Skalierbarkeit : Unterstützt die Integration von Tausenden von Agenten und macht es zu einer idealen Lösung für die Verarbeitung und Datenanalyse in großem Maßstab.

Methoden

Verfahren	Beschreibung	Parameter	Rückgabewert
__init__	Initialisieren Sie die Tabelle	name : Name des Schwarms description : Beschreibung des Schwarms agents : Liste der Agentenobjekte autosave_on : boolean, um autosave zu aktivieren save_file_path : Pfad, um die Tabelle zu speichern run_all_agents : boolean, um alle Agenten auszuführen oder nicht max_loops : maximale Anzahl von Schleifen	Keiner
run	Den Schwarm ausführen	task : Eingabeaufgabe für den Schwarm	Wörterbuch von Agentenausgängen

Eingänge

Eingang	Typ	Beschreibung
name	str	Name des Schwarms
description	str	Beschreibung des Zwecks des Schwarms
agents	Liste [Agent]	Liste der Agentenobjekte, die im Schwarm verwendet werden sollen
autosave_on	bool	Aktivieren Sie die Ergebnisse der Ergebnisse
save_file_path	str	Pfad zum Speichern der Tabellenkalkulationsergebnisse
run_all_agents	bool	Ob Sie alle Agenten ausführen oder basierend auf der Relevanz auswählen möchten
max_loops	int	Maximale Anzahl der Verarbeitungsschleifen

Ausgabe

Die run -Methode gibt ein Wörterbuch zurück, das die Ausgänge eines jeden Agenten enthält, der die Aufgabe verarbeitet hat.

Erfahren Sie hier mehr in den Dokumenten:

 import os
from swarms import Agent
from swarm_models import OpenAIChat
from swarms . structs . spreadsheet_swarm import SpreadSheetSwarm

# Define custom system prompts for each social media platform
TWITTER_AGENT_SYS_PROMPT = """
You are a Twitter marketing expert specializing in real estate. Your task is to create engaging, concise tweets to promote properties, analyze trends to maximize engagement, and use appropriate hashtags and timing to reach potential buyers.
"""

INSTAGRAM_AGENT_SYS_PROMPT = """
You are an Instagram marketing expert focusing on real estate. Your task is to create visually appealing posts with engaging captions and hashtags to showcase properties, targeting specific demographics interested in real estate.
"""

FACEBOOK_AGENT_SYS_PROMPT = """
You are a Facebook marketing expert for real estate. Your task is to craft posts optimized for engagement and reach on Facebook, including using images, links, and targeted messaging to attract potential property buyers.
"""

LINKEDIN_AGENT_SYS_PROMPT = """
You are a LinkedIn marketing expert for the real estate industry. Your task is to create professional and informative posts, highlighting property features, market trends, and investment opportunities, tailored to professionals and investors.
"""

EMAIL_AGENT_SYS_PROMPT = """
You are an Email marketing expert specializing in real estate. Your task is to write compelling email campaigns to promote properties, focusing on personalization, subject lines, and effective call-to-action strategies to drive conversions.
"""

# Example usage:
api_key = os . getenv ( "OPENAI_API_KEY" )

# Model
model = OpenAIChat (
    openai_api_key = api_key , model_name = "gpt-4o-mini" , temperature = 0.1
)

# Initialize your agents for different social media platforms
agents = [
    Agent (
        agent_name = "Twitter-RealEstate-Agent" ,
        system_prompt = TWITTER_AGENT_SYS_PROMPT ,
        llm = model ,
        max_loops = 1 ,
        dynamic_temperature_enabled = True ,
        saved_state_path = "twitter_realestate_agent.json" ,
        user_name = "realestate_swarms" ,
        retry_attempts = 1 ,
    ),
    Agent (
        agent_name = "Instagram-RealEstate-Agent" ,
        system_prompt = INSTAGRAM_AGENT_SYS_PROMPT ,
        llm = model ,
        max_loops = 1 ,
        dynamic_temperature_enabled = True ,
        saved_state_path = "instagram_realestate_agent.json" ,
        user_name = "realestate_swarms" ,
        retry_attempts = 1 ,
    ),
    Agent (
        agent_name = "Facebook-RealEstate-Agent" ,
        system_prompt = FACEBOOK_AGENT_SYS_PROMPT ,
        llm = model ,
        max_loops = 1 ,
        dynamic_temperature_enabled = True ,
        saved_state_path = "facebook_realestate_agent.json" ,
        user_name = "realestate_swarms" ,
        retry_attempts = 1 ,
    ),
    Agent (
        agent_name = "LinkedIn-RealEstate-Agent" ,
        system_prompt = LINKEDIN_AGENT_SYS_PROMPT ,
        llm = model ,
        max_loops = 1 ,
        dynamic_temperature_enabled = True ,
        saved_state_path = "linkedin_realestate_agent.json" ,
        user_name = "realestate_swarms" ,
        retry_attempts = 1 ,
    ),
    Agent (
        agent_name = "Email-RealEstate-Agent" ,
        system_prompt = EMAIL_AGENT_SYS_PROMPT ,
        llm = model ,
        max_loops = 1 ,
        dynamic_temperature_enabled = True ,
        saved_state_path = "email_realestate_agent.json" ,
        user_name = "realestate_swarms" ,
        retry_attempts = 1 ,
    ),
]

# Create a Swarm with the list of agents
swarm = SpreadSheetSwarm (
    name = "Real-Estate-Marketing-Swarm" ,
    description = "A swarm that processes real estate marketing tasks using multiple agents on different threads." ,
    agents = agents ,
    autosave_on = True ,
    save_file_path = "real_estate_marketing_spreadsheet.csv" ,
    run_all_agents = False ,
    max_loops = 2 ,
)

# Run the swarm
swarm . run (
    task = """
    Create posts to promote luxury properties in North Texas, highlighting their features, location, and investment potential. Include relevant hashtags, images, and engaging captions.

    
    Property:
    $10,399,000
    1609 Meandering Way Dr, Roanoke, TX 76262
    Link to the property: https://www.zillow.com/homedetails/1609-Meandering-Way-Dr-Roanoke-TX-76262/308879785_zpid/
    
    What's special
    Unveiling a new custom estate in the prestigious gated Quail Hollow Estates! This impeccable residence, set on a sprawling acre surrounded by majestic trees, features a gourmet kitchen equipped with top-tier Subzero and Wolf appliances. European soft-close cabinets and drawers, paired with a double Cambria Quartzite island, perfect for family gatherings. The first-floor game room&media room add extra layers of entertainment. Step into the outdoor sanctuary, where a sparkling pool and spa, and sunken fire pit, beckon leisure. The lavish master suite features stunning marble accents, custom his&her closets, and a secure storm shelter.Throughout the home,indulge in the visual charm of designer lighting and wallpaper, elevating every space. The property is complete with a 6-car garage and a sports court, catering to the preferences of basketball or pickleball enthusiasts. This residence seamlessly combines luxury&recreational amenities, making it a must-see for the discerning buyer.
    
    Facts & features
    Interior
    Bedrooms & bathrooms
    Bedrooms: 6
    Bathrooms: 8
    Full bathrooms: 7
    1/2 bathrooms: 1
    Primary bedroom
    Bedroom
    Features: Built-in Features, En Suite Bathroom, Walk-In Closet(s)
    Cooling
    Central Air, Ceiling Fan(s), Electric
    Appliances
    Included: Built-In Gas Range, Built-In Refrigerator, Double Oven, Dishwasher, Gas Cooktop, Disposal, Ice Maker, Microwave, Range, Refrigerator, Some Commercial Grade, Vented Exhaust Fan, Warming Drawer, Wine Cooler
    Features
    Wet Bar, Built-in Features, Dry Bar, Decorative/Designer Lighting Fixtures, Eat-in Kitchen, Elevator, High Speed Internet, Kitchen Island, Pantry, Smart Home, Cable TV, Walk-In Closet(s), Wired for Sound
    Flooring: Hardwood
    Has basement: No
    Number of fireplaces: 3
    Fireplace features: Living Room, Primary Bedroom
    Interior area
    Total interior livable area: 10,466 sqft
    Total spaces: 12
    Parking features: Additional Parking
    Attached garage spaces: 6
    Carport spaces: 6
    Features
    Levels: Two
    Stories: 2
    Patio & porch: Covered
    Exterior features: Built-in Barbecue, Barbecue, Gas Grill, Lighting, Outdoor Grill, Outdoor Living Area, Private Yard, Sport Court, Fire Pit
    Pool features: Heated, In Ground, Pool, Pool/Spa Combo
    Fencing: Wrought Iron
    Lot
    Size: 1.05 Acres
    Details
    Additional structures: Outdoor Kitchen
    Parcel number: 42232692
    Special conditions: Standard
    Construction
    Type & style
    Home type: SingleFamily
    Architectural style: Contemporary/Modern,Detached
    Property subtype: Single Family Residence
    """
)

ForestSwarm

Die ForestSwarm -Architektur wurde für eine effiziente Aufgabenzuweisung entwickelt, indem der am besten geeignete Agent aus einer Sammlung von Bäumen dynamisch ausgewählt wird. Dies wird durch eine asynchrone Aufgabenverarbeitung erreicht, bei der Agenten aufgrund ihrer Relevanz für die jeweilige Aufgabe ausgewählt werden. Die Relevanz wird durch Berechnung der Ähnlichkeit zwischen den mit jedem Agenten zugeordneten Systemaufforderungen und den in der Aufgabe selbst vorhandenen Schlüsselwörtern bestimmt. Für ein eingehenderes Verständnis für die Funktionsweise ForestSwarm finden Sie in der offiziellen Dokumentation.

Methoden

Verfahren	Beschreibung	Parameter	Rückgabewert
__init__	Initialisieren Sie die Waldwarm	trees : Liste der Baumobjekte	Keiner
run	Führen Sie die Forestswarm aus	task : Eingabeaufgabe für den Schwarm	Ausgabe vom relevantesten Agenten

Eingänge

Eingang	Typ	Beschreibung
trees	Liste [Baum]	Liste der Baumobjekte, die jeweils TreeAg -Objekte enthalten
task	str	Die Aufgabe, die von den Forestswarm bearbeitet werden soll

Ausgabe

Die run -Methode gibt die Ausgabe vom relevantesten Agenten zurück, das basierend auf der Eingabeaufgabe ausgewählt wurde.

 from swarms . structs . tree_swarm import TreeAgent , Tree , ForestSwarm

# Create agents with varying system prompts and dynamically generated distances/keywords
agents_tree1 = [
    TreeAgent (
        system_prompt = """You are an expert Stock Analysis Agent with deep knowledge of financial markets, technical analysis, and fundamental analysis. Your primary function is to analyze stock performance, market trends, and provide actionable insights. When analyzing stocks:

1. Always start with a brief overview of the current market conditions.
2. Use a combination of technical indicators (e.g., moving averages, RSI, MACD) and fundamental metrics (e.g., P/E ratio, EPS growth, debt-to-equity).
3. Consider both short-term and long-term perspectives in your analysis.
4. Provide clear buy, hold, or sell recommendations with supporting rationale.
5. Highlight potential risks and opportunities specific to each stock or sector.
6. Use bullet points for clarity when listing key points or metrics.
7. If relevant, compare the stock to its peers or sector benchmarks.

Remember to maintain objectivity and base your analysis on factual data. If asked about future performance, always include a disclaimer about market unpredictability. Your goal is to provide comprehensive, accurate, and actionable stock analysis to inform investment decisions.""" ,
        agent_name = "Stock Analysis Agent" ,
    ),
    TreeAgent (
        system_prompt = """You are a highly skilled Financial Planning Agent, specializing in personal and corporate financial strategies. Your role is to provide comprehensive financial advice tailored to each client's unique situation. When creating financial plans:

1. Begin by asking key questions about the client's financial goals, current situation, and risk tolerance.
2. Develop a holistic view of the client's finances, including income, expenses, assets, and liabilities.
3. Create detailed, step-by-step action plans to achieve financial goals.
4. Provide specific recommendations for budgeting, saving, and investing.
5. Consider tax implications and suggest tax-efficient strategies.
6. Incorporate risk management and insurance planning into your recommendations.
7. Use charts or tables to illustrate financial projections and scenarios.
8. Regularly suggest reviewing and adjusting the plan as circumstances change.

Always prioritize the client's best interests and adhere to fiduciary standards. Explain complex financial concepts in simple terms, and be prepared to justify your recommendations with data and reasoning.""" ,
        agent_name = "Financial Planning Agent" ,
    ),
    TreeAgent (
        agent_name = "Retirement Strategy Agent" ,
        system_prompt = """You are a specialized Retirement Strategy Agent, focused on helping individuals and couples plan for a secure and comfortable retirement. Your expertise covers various aspects of retirement planning, including savings strategies, investment allocation, and income generation during retirement. When developing retirement strategies:

1. Start by assessing the client's current age, desired retirement age, and expected lifespan.
2. Calculate retirement savings goals based on desired lifestyle and projected expenses.
3. Analyze current retirement accounts (e.g., 401(k), IRA) and suggest optimization strategies.
4. Provide guidance on asset allocation and rebalancing as retirement approaches.
5. Explain various retirement income sources (e.g., Social Security, pensions, annuities).
6. Discuss healthcare costs and long-term care planning.
7. Offer strategies for tax-efficient withdrawals during retirement.
8. Consider estate planning and legacy goals in your recommendations.

Use Monte Carlo simulations or other statistical tools to illustrate the probability of retirement success. Always emphasize the importance of starting early and the power of compound interest. Be prepared to adjust strategies based on changing market conditions or personal circumstances.""" ,
    ),
]

agents_tree2 = [
    TreeAgent (
        system_prompt = """You are a knowledgeable Tax Filing Agent, specializing in personal and business tax preparation and strategy. Your role is to ensure accurate tax filings while maximizing legitimate deductions and credits. When assisting with tax matters:

1. Start by gathering all necessary financial information and documents.
2. Stay up-to-date with the latest tax laws and regulations, including state-specific rules.
3. Identify all applicable deductions and credits based on the client's situation.
4. Provide step-by-step guidance for completing tax forms accurately.
5. Explain tax implications of various financial decisions.
6. Offer strategies for tax-efficient investing and income management.
7. Assist with estimated tax payments for self-employed individuals or businesses.
8. Advise on record-keeping practices for tax purposes.

Always prioritize compliance with tax laws while ethically minimizing tax liability. Be prepared to explain complex tax concepts in simple terms and provide rationale for your recommendations. If a situation is beyond your expertise, advise consulting a certified tax professional or IRS resources.""" ,
        agent_name = "Tax Filing Agent" ,
    ),
    TreeAgent (
        system_prompt = """You are a sophisticated Investment Strategy Agent, adept at creating and managing investment portfolios to meet diverse financial goals. Your expertise covers various asset classes, market analysis, and risk management techniques. When developing investment strategies:

1. Begin by assessing the client's investment goals, time horizon, and risk tolerance.
2. Provide a comprehensive overview of different asset classes and their risk-return profiles.
3. Create diversified portfolio recommendations based on modern portfolio theory.
4. Explain the benefits and risks of various investment vehicles (e.g., stocks, bonds, ETFs, mutual funds).
5. Incorporate both passive and active investment strategies as appropriate.
6. Discuss the importance of regular portfolio rebalancing and provide a rebalancing strategy.
7. Consider tax implications of investment decisions and suggest tax-efficient strategies.
8. Provide ongoing market analysis and suggest portfolio adjustments as needed.

Use historical data and forward-looking projections to illustrate potential outcomes. Always emphasize the importance of long-term investing and the risks of market timing. Be prepared to explain complex investment concepts in clear, accessible language.""" ,
        agent_name = "Investment Strategy Agent" ,
    ),
    TreeAgent (
        system_prompt = """You are a specialized ROTH IRA Agent, focusing on the intricacies of Roth Individual Retirement Accounts. Your role is to provide expert guidance on Roth IRA rules, benefits, and strategies to maximize their value for retirement planning. When advising on Roth IRAs:

1. Explain the fundamental differences between traditional and Roth IRAs.
2. Clarify Roth IRA contribution limits and income eligibility requirements.
3. Discuss the tax advantages of Roth IRAs, including tax-free growth and withdrawals.
4. Provide guidance on Roth IRA conversion strategies and their tax implications.
5. Explain the five-year rule and how it affects Roth IRA withdrawals.
6. Offer strategies for maximizing Roth IRA contributions, such as the backdoor Roth IRA method.
7. Discuss how Roth IRAs fit into overall retirement and estate planning strategies.
8. Provide insights on investment choices within a Roth IRA to maximize tax-free growth.

Always stay current with IRS regulations regarding Roth IRAs. Be prepared to provide numerical examples to illustrate the long-term benefits of Roth IRAs. Emphasize the importance of considering individual financial situations when making Roth IRA decisions.""" ,
        agent_name = "ROTH IRA Agent" ,
    ),
]

# Create trees
tree1 = Tree ( tree_name = "Financial Tree" , agents = agents_tree1 )
tree2 = Tree ( tree_name = "Investment Tree" , agents = agents_tree2 )

# Create the ForestSwarm
multi_agent_structure = ForestSwarm ( trees = [ tree1 , tree2 ])

# Run a task
task = "What are the best platforms to do our taxes on"
output = multi_agent_structure . run ( task )
print ( output )

SwarmRouter

Die SwarmRouter -Klasse ist ein flexibles Routing -System, mit dem verschiedene Arten von Schwärmen für die Ausführung von Aufgaben verwaltet werden. Es bietet eine einheitliche Schnittstelle zur Interaktion mit verschiedenen Schwarmtypen, einschließlich AgentRearrange , MixtureOfAgents , SpreadSheetSwarm , SequentialWorkflow Workflow und ConcurrentWorkflow . Wir werden hier immer mehr Schwarmarchitekturen hinzufügen, wenn wir mit neuen Architekturen voranschreiten.

Attribute:

• name (STR): Name der Swarmrouter -Instanz.
• description (STR): Beschreibung der Swarmrouter -Instanz.
• max_loops (int): maximale Anzahl von Schleifen, die ausführen sollen.
• agents (Liste [Agent]): Liste der Agentenobjekte, die im Schwarm verwendet werden sollen.
• swarm_type (SWARMTYPE): Art des zu verwendenden Schwarms.
• swarm (Union [AgentreRraange, Mischofagenten, Tabellenkalkulelle, sequentielles Workflow, gleichzeitiger Workflow]): Instantiertes Schwarmobjekt.
• logs (Liste [Swarmlog]): Liste der während der Operationen erfassten Protokolleinträge.

Methoden:

• __init__(self, name: str, description: str, max_loops: int, agents: List[Agent], swarm_type: SwarmType, *args, **kwargs) : Initialisieren Sie den Swarmrouter.
• _create_swarm(self, *args, **kwargs) : Erstellen und zurück den angegebenen Schwarmtyp.
• _log(self, level: str, message: str, task: str, metadata: Dict[str, Any]) : Erstellen Sie einen Protokolleintrag und fügen Sie ihn der Liste der Protokolle hinzu.
• run(self, task: str, *args, **kwargs) : Führen Sie die angegebene Aufgabe auf dem ausgewählten Schwarm aus.
• get_logs(self) : Alle protokollierten Einträge abrufen.

 import os
from dotenv import load_dotenv
from swarms import Agent
from swarm_models import OpenAIChat
from swarms . structs . swarm_router import SwarmRouter , SwarmType

load_dotenv ()

# Get the OpenAI API key from the environment variable
api_key = os . getenv ( "GROQ_API_KEY" )

# Model
model = OpenAIChat (
    openai_api_base = "https://api.groq.com/openai/v1" ,
    openai_api_key = api_key ,
    model_name = "llama-3.1-70b-versatile" ,
    temperature = 0.1 ,
)
# Define specialized system prompts for each agent
DATA_EXTRACTOR_PROMPT = """You are a highly specialized private equity agent focused on data extraction from various documents. Your expertise includes:
1. Extracting key financial metrics (revenue, EBITDA, growth rates, etc.) from financial statements and reports
2. Identifying and extracting important contract terms from legal documents
3. Pulling out relevant market data from industry reports and analyses
4. Extracting operational KPIs from management presentations and internal reports
5. Identifying and extracting key personnel information from organizational charts and bios
Provide accurate, structured data extracted from various document types to support investment analysis."""

SUMMARIZER_PROMPT = """You are an expert private equity agent specializing in summarizing complex documents. Your core competencies include:
1. Distilling lengthy financial reports into concise executive summaries
2. Summarizing legal documents, highlighting key terms and potential risks
3. Condensing industry reports to capture essential market trends and competitive dynamics
4. Summarizing management presentations to highlight key strategic initiatives and projections
5. Creating brief overviews of technical documents, emphasizing critical points for non-technical stakeholders
Deliver clear, concise summaries that capture the essence of various documents while highlighting information crucial for investment decisions."""

FINANCIAL_ANALYST_PROMPT = """You are a specialized private equity agent focused on financial analysis. Your key responsibilities include:
1. Analyzing historical financial statements to identify trends and potential issues
2. Evaluating the quality of earnings and potential adjustments to EBITDA
3. Assessing working capital requirements and cash flow dynamics
4. Analyzing capital structure and debt capacity
5. Evaluating financial projections and underlying assumptions
Provide thorough, insightful financial analysis to inform investment decisions and valuation."""

MARKET_ANALYST_PROMPT = """You are a highly skilled private equity agent specializing in market analysis. Your expertise covers:
1. Analyzing industry trends, growth drivers, and potential disruptors
2. Evaluating competitive landscape and market positioning
3. Assessing market size, segmentation, and growth potential
4. Analyzing customer dynamics, including concentration and loyalty
5. Identifying potential regulatory or macroeconomic impacts on the market
Deliver comprehensive market analysis to assess the attractiveness and risks of potential investments."""

OPERATIONAL_ANALYST_PROMPT = """You are an expert private equity agent focused on operational analysis. Your core competencies include:
1. Evaluating operational efficiency and identifying improvement opportunities
2. Analyzing supply chain and procurement processes
3. Assessing sales and marketing effectiveness
4. Evaluating IT systems and digital capabilities
5. Identifying potential synergies in merger or add-on acquisition scenarios
Provide detailed operational analysis to uncover value creation opportunities and potential risks."""

# Initialize specialized agents
data_extractor_agent = Agent (
    agent_name = "Data-Extractor" ,
    system_prompt = DATA_EXTRACTOR_PROMPT ,
    llm = model ,
    max_loops = 1 ,
    autosave = True ,
    verbose = True ,
    dynamic_temperature_enabled = True ,
    saved_state_path = "data_extractor_agent.json" ,
    user_name = "pe_firm" ,
    retry_attempts = 1 ,
    context_length = 200000 ,
    output_type = "string" ,
)

summarizer_agent = Agent (
    agent_name = "Document-Summarizer" ,
    system_prompt = SUMMARIZER_PROMPT ,
    llm = model ,
    max_loops = 1 ,
    autosave = True ,
    verbose = True ,
    dynamic_temperature_enabled = True ,
    saved_state_path = "summarizer_agent.json" ,
    user_name = "pe_firm" ,
    retry_attempts = 1 ,
    context_length = 200000 ,
    output_type = "string" ,
)

financial_analyst_agent = Agent (
    agent_name = "Financial-Analyst" ,
    system_prompt = FINANCIAL_ANALYST_PROMPT ,
    llm = model ,
    max_loops = 1 ,
    autosave = True ,
    verbose = True ,
    dynamic_temperature_enabled = True ,
    saved_state_path = "financial_analyst_agent.json" ,
    user_name = "pe_firm" ,
    retry_attempts = 1 ,
    context_length = 200000 ,
    output_type = "string" ,
)

market_analyst_agent = Agent (
    agent_name = "Market-Analyst" ,
    system_prompt = MARKET_ANALYST_PROMPT ,
    llm = model ,
    max_loops = 1 ,
    autosave = True ,
    verbose = True ,
    dynamic_temperature_enabled = True ,
    saved_state_path = "market_analyst_agent.json" ,
    user_name = "pe_firm" ,
    retry_attempts = 1 ,
    context_length = 200000 ,
    output_type = "string" ,
)

operational_analyst_agent = Agent (
    agent_name = "Operational-Analyst" ,
    system_prompt = OPERATIONAL_ANALYST_PROMPT ,
    llm = model ,
    max_loops = 1 ,
    autosave = True ,
    verbose = True ,
    dynamic_temperature_enabled = True ,
    saved_state_path = "operational_analyst_agent.json" ,
    user_name = "pe_firm" ,
    retry_attempts = 1 ,
    context_length = 200000 ,
    output_type = "string" ,
)

# Initialize the SwarmRouter
router = SwarmRouter (
    name = "pe-document-analysis-swarm" ,
    description = "Analyze documents for private equity due diligence and investment decision-making" ,
    max_loops = 1 ,
    agents = [
        data_extractor_agent ,
        summarizer_agent ,
        financial_analyst_agent ,
        market_analyst_agent ,
        operational_analyst_agent ,
    ],
    swarm_type = "ConcurrentWorkflow" ,  # or "SequentialWorkflow" or "ConcurrentWorkflow" or
)

# Example usage
if __name__ == "__main__" :
    # Run a comprehensive private equity document analysis task
    result = router . run (
        "Where is the best place to find template term sheets for series A startups. Provide links and references"
    )
    print ( result )

    # Retrieve and print logs
    for log in router . get_logs ():
        print ( f" { log . timestamp } - { log . level } : { log . message } " )

Schwarmtypen ändern

Sie können mehrere Schwarmrouter -Instanzen mit unterschiedlichen Schwarmtypen erstellen:

 sequential_router = SwarmRouter (
    name = "SequentialRouter" ,
    agents = [
        data_extractor_agent ,
        summarizer_agent ,
        financial_analyst_agent ,
        market_analyst_agent ,
        operational_analyst_agent ,
    ],
    swarm_type = SwarmType . SequentialWorkflow
)

concurrent_router = SwarmRouter (
    name = "ConcurrentRouter" ,
    agents = [
        data_extractor_agent ,
        summarizer_agent ,
        financial_analyst_agent ,
        market_analyst_agent ,
        operational_analyst_agent ,
    ],
    swarm_type = SwarmType . ConcurrentWorkflow
)

Agentrearrange

Anwendungsfall: Optimierung der Agentenreihenfolge für komplexe mehrstufige Aufgaben.

 rearrange_router = SwarmRouter (
    name = "TaskOptimizer" ,
    description = "Optimize agent order for multi-step tasks" ,
    max_loops = 3 ,
    agents = [
        data_extractor_agent ,
        summarizer_agent ,
        financial_analyst_agent ,
        market_analyst_agent ,
        operational_analyst_agent ,
    ],
    swarm_type = SwarmType . AgentRearrange ,
    flow = f" { data_extractor . name } -> { analyzer . name } -> { summarizer . name } "
)

result = rearrange_router . run ( "Analyze and summarize the quarterly financial report" )

Mischung

Anwendungsfall: Kombination verschiedener Experten für umfassende Analysen.

 mixture_router = SwarmRouter (
    name = "ExpertPanel" ,
    description = "Combine insights from various expert agents" ,
    max_loops = 1 ,
    agents = [
        data_extractor_agent ,
        summarizer_agent ,
        financial_analyst_agent ,
        market_analyst_agent ,
        operational_analyst_agent ,
    ],
    swarm_type = SwarmType . MixtureOfAgents
)

result = mixture_router . run ( "Evaluate the potential acquisition of TechStartup Inc." )

---

Onboarding -Sitzung

Machen Sie sich jetzt mit dem Schöpfer und dem Hauptbetrieb von Swarms, Kye Gomez, an Bord, der Ihnen zeigt, wie Sie mit der Installation, den Nutzungsbeispielen beginnen und Ihren benutzerdefinierten Anwendungsfall aufbauen können! KLICKEN SIE HIER

---

Dokumentation

Die Dokumentation befindet sich hier unter: docs.swarms.world

---

Ordnerstruktur

Das Schwarmpaket wurde sorgfältig für extreme Nutzbarkeit und Verständnis gefertigt. Das swarms.structs ist in verschiedene Module wie swarms.agents aufgeteilt Agent Agentenstrukturen. Die 3 wichtigsten sind structs , models und agents .

├── __init__.py
├── agents
├── artifacts
├── memory
├── schemas
├── models - > swarm_models
├── prompts
├── structs
├── telemetry
├── tools
├── utils
└── workers

---

? Beiträge:

Der einfachste Weg, um einen Beitrag zu leisten, besteht darin, ein Problem mit dem good first issue -Tag auszuwählen? Lesen Sie hier die beitragenden Richtlinien. Fehlerbericht? Datei hier | Feature -Anfrage? Datei hier

Swarms ist ein Open-Source-Projekt, und Beiträge sind sehr willkommen. Wenn Sie einen Beitrag leisten möchten, können Sie neue Funktionen erstellen, Fehler beheben oder die Infrastruktur verbessern. Weitere Informationen finden Sie im beitragen.md und in unserem Beitrag zur Teilnahme an Roadmap -Diskussionen!

---

Beschleunigen Sie den Rückstand

Beschleunigen Sie Fehler, Funktionen und Demos, um uns hier zu implementieren:

Gemeinschaft

Schließen Sie sich unserer wachsenden Gemeinschaft auf der ganzen Welt an, um Unterstützung, Ideen und Diskussionen über Schwärme in Echtzeit zu erhalten?

• Sehen Sie sich unseren offiziellen Blog an
• Chatten Sie live mit uns auf Zwietracht
• Folgen Sie uns auf Twitter
• Verbinden Sie sich mit uns auf LinkedIn
• Besuchen Sie uns auf YouTube
• Schließen Sie sich der Swarms Community auf Zwietracht an!
• Nehmen Sie jeden Donnerstag um 13.00 Uhr in unserer Swarms Community zusammen, um das Potenzial autonomer Agenten bei der Automatisierung Ihrer täglichen Aufgaben zu erschließen, die sich hier anmelden

Lizenz

GNU Affero Allgemeine öffentliche Lizenz