swarms

Le cadre d'orchestration multi-agents de la production de qualité d'entreprise

? Twitter • ? Discord • plate-forme Swarms • ? Documentation

Caractéristiques

Catégorie	Caractéristiques	Avantages
? Architecture d'entreprise	• Infrastructure prête à la production • Systèmes de haute fiabilité • Design modulaire • journalisation complète	• Réduction des temps d'arrêt • Entretien plus facile • Un meilleur débogage • Surveillance améliorée
? Orchestration d'agent	• essaims hiérarchiques • Traitement parallèle • flux de travail séquentiels • workflows basés sur des graphiques • Réarrangement dynamique des agents	• Gestion des tâches complexes • Amélioration des performances • flux de travail flexibles • Exécution optimisée
Capacités d'intégration	• Prise en charge multimodèle • Création des agents personnalisés • Bibliothèque d'outils approfondie • plusieurs systèmes de mémoire	• Flexibilité des prestataires • Solutions personnalisées • Fonctionnalités étendues • Gestion améliorée de la mémoire
? Évolutivité	• Traitement simultané • Gestion des ressources • Équilibrage de charge • Échelle horizontale	• Débit plus élevé • Utilisation efficace des ressources • meilleure performance • Échelle facile
Outils de développeur	• API simple • Documentation approfondie • Communauté active • Outils CLI	• Développement plus rapide • Courbe d'apprentissage facile • Soutien communautaire • Déploiement rapide
? Fonctionnalités de sécurité	• Gestion des erreurs • Limitation des taux • surveillance de l'intégration • Audit journalisation	• Amélioration de la fiabilité • Protection de l'API • Une meilleure surveillance • Suivi amélioré
Fonctionnalités avancées	• Armoire de calcul • Chat de groupe • Registre des agents • Mélange d'agents	• Gestion des agents de masse • AI collaboratif • Contrôle centralisé • Solutions complexes
? Soutien du fournisseur	• Openai • anthropique • chromadb • Provideurs personnalisés	• Flexibilité des prestataires • Options de stockage • Intégration personnalisée • Indépendance du vendeur
? Caractéristiques de production	• Retries automatiques • Support asynchrone • Gestion de l'environnement • Type de sécurité	• meilleure fiabilité • Amélioration des performances • Configuration facile • Code plus sûr
Prise en charge du cas d'utilisation	• Agents spécifiques à la tâche • workflows personnalisés • Solutions de l'industrie • Framework extensible	• Déploiement rapide • Solutions flexibles • Présenté de l'industrie • Personnalisation facile

---

Exigences

• python3.10 ou plus!
• $ pip install -U swarms et, n'oubliez pas d'installer des essaims!
• .env Fichier avec des clés API de vos fournisseurs comme OPENAI_API_KEY , ANTHROPIC_API_KEY
• Définissez une variable .env avec votre espace de travail souhaité dir: WORKSPACE_DIR="agent_workspace" ou faites-le dans votre terminal avec export WORKSPACE_DIR="agent_workspace"
• Enfin, swarms onboarding pour vous aider à démarrer.

Guides et procédures pas à pas

Reportez-vous à notre documentation pour les détails de mise en œuvre de la note de production.

Section	Links
Installation	Installation
Start	Commencer
Mécanismes internes d'agent	Architecture d'agent
API d'agent	API d'agent
Intégration d'agents externes Grippape, Autogen, etc.	Intégration des API externes
Création d'agents de Yaml	Création d'agents de Yaml
Pourquoi tu as besoin d'essaims	Pourquoi la collaboration multi-agents est nécessaire
Analyse des architectures d'essaim	Architectures d'essaim
Choisir le bon essaim pour votre problème commercial¶	CLIQUEZ ICI
Docs AgrantArrange	CLIQUEZ ICI

Installer

$ pip3 install -U swarms

Embarquement

Maintenant que vous avez téléchargé des essaims avec pip3 install -U swarms , nous avons accès à la CLI . Soyez à bord avec CLI maintenant avec:

swarms onboarding

Vous pouvez également exécuter cette commande pour obtenir de l'aide:

swarms help

Pour plus de documentation sur la CLI, cliquez ici

---

Exemples d'utilisation?

Voici quelques exemples de scripts pour vous aider à démarrer. Pour une documentation plus complète, visitez nos documents.

Exemple de nom	Description	Type d'exemples	Lien
Exemples d'essaims	Une collection d'exemples simples pour démontrer les capacités d'essaims.	Utilisation de base	https://github.com/the-swarm-corporation/swarms-examples?tab=readme-ov-file
Livre de cuisine	Un guide complet avec des recettes pour divers cas d'utilisation et scénarios.	Utilisation avancée	https://github.com/the-swarm-corporation/cookbook

---

Classe Agent

La classe Agent est une composante fondamentale du cadre Swarms, conçu pour exécuter des tâches de manière autonome. Il fusionne les LLM, les outils et les capacités de mémoire à long terme pour créer un agent complet. La classe Agent est hautement personnalisable, permettant un contrôle à grain fin sur son comportement et ses interactions.

méthode run

La méthode run est le point d'entrée principal pour exécuter des tâches avec une instance Agent . Il accepte une chaîne de tâche comme la tâche d'entrée principale et le traite en fonction de la configuration de l'agent. Et, il peut également accepter un paramètre img tel que img="image_filepath.png pour traiter les images si vous avez un VLM

Paramètres et personnalisation

La classe Agent propose une gamme de paramètres pour adapter son comportement à des besoins spécifiques. Certains paramètres clés comprennent:

Paramètre	Description	Valeur par défaut
agent_name	Le nom de l'agent.	"DefaultAgent"
system_prompt	L'invite du système à utiliser pour l'agent.	"Invite du système par défaut."
llm	Le modèle de langue à utiliser pour le traitement des tâches.	Instance OpenAIChat
max_loops	Le nombre maximum de boucles à exécuter pour une tâche.	1
autosave	Permet ou désactive la sauvegarde de l'état de l'agent.	FAUX
dashboard	Active ou désactive le tableau de bord pour l'agent.	FAUX
verbose	Contrôle la verbosité de la sortie de l'agent.	FAUX
dynamic_temperature_enabled	Active ou désactive le réglage de la température dynamique pour le modèle de langue.	FAUX
saved_state_path	Le chemin pour sauver l'état de l'agent.	"agent_state.json"
user_name	Le nom d'utilisateur associé à l'agent.	"default_user"
retry_attempts	Le nombre de tentatives de réessayer pour les tâches ratées.	1
context_length	La longueur maximale du contexte à considérer pour les tâches.	200000
return_step_meta	Contrôle l'opportunité de retourner les métadonnées des étapes dans la sortie.	FAUX
output_type	Le type de sortie à retourner (par exemple, "JSON", "String").	"chaîne"

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

---

Intégration de chiffon avec des essaims pour une mémoire à long terme améliorée

Agent équipé d'une mémoire à long terme quasi-infinie en utilisant RAG (graphique d'agent relationnel) pour la compréhension avancée des documents, l'analyse et les capacités de récupération.

Diagramme de sirène pour l'intégration des chiffons

 graphique TD
    A [Initialiser l'agent avec RAG] -> B [Tâche de réception]
    B -> c [requête à long terme mémoire]
    C -> D [Tâche de traitement avec le contexte]
    D -> e [générer une réponse]
    E -> f [Mettre à jour la mémoire à long terme]
    F -> g [sortie de retour]

Étape 1: Initialisez le client chromadb

 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
)

Étape 2: Définissez le modèle

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

Étape 3: Initialisez l'agent avec un chiffon

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

---

Paramètres de l'agent Mish

Nous fournissons une vaste gamme de fonctionnalités pour enregistrer les états d'agent à l'aide de JSON, YAML, TOML, de téléchargement de PDF, de travaux par lots et bien plus encore!

Tableau de méthode

Méthode	Description
to_dict()	Convertit l'objet d'agent en un dictionnaire.
to_toml()	Convertit l'objet Agent en une chaîne Toml.
model_dump_json()	Jette le modèle dans un fichier JSON.
model_dump_yaml()	Jette le modèle dans un fichier YAML.
ingest_docs()	Ingère des documents dans la base de connaissances de l'agent.
receive_message()	Reçoit un message d'un utilisateur et le traite.
send_agent_message()	Envoie un message de l'agent à un utilisateur.
filtered_run()	Exécute l'agent avec une invite système filtrée.
bulk_run()	Exécute l'agent avec plusieurs invites système.
add_memory()	Ajoute une mémoire à l'agent.
check_available_tokens()	Vérifie le nombre de jetons disponibles pour l'agent.
tokens_checks()	Effectue des vérifications de jetons pour l'agent.
print_dashboard()	Imprime le tableau de bord de l'agent.
get_docs_from_doc_folders()	Repare tous les documents des dossiers DOC.
activate_agentops()	Active les opérations des agents.
check_end_session_agentops()	Vérifie la fin de la session pour les opérations d'agent.

 # # 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 avec pydante Basemodel comme type de sortie

Ce qui suit est un exemple d'un agent qui prend en sorte un pydante de base et le sort en même temps:

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

Agent autonome multi-modal

Exécutez l'agent avec plusieurs modalités utiles pour diverses tâches du monde réel dans la fabrication, la logistique et la santé.

 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 est un agent qui peut utiliser des outils via des appels de fonction JSON. Il saisit tout modèle open source de HuggingFace et est extrêmement modulaire et se branche et joue. Nous avons besoin d'aide à ajouter un support général à tous les modèles bientôt.

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

Intégrer des agents externes

L'intégration d'agents externes des autres cadres d'agent est facile avec les essaims.

Mesures:

1. Créer une nouvelle classe qui hérite Agent
2. Créez une méthode .run(task: str) -> str qui exécute l'agent et renvoie la réponse.
3. Le nouvel agent doit renvoyer une chaîne de la réponse. Mais vous pouvez ajouter des méthodes supplémentaires pour enregistrer la sortie à JSON.

Exemple de Griptape

Par exemple, voici un exemple sur la façon de créer un agent à partir de Griptape.

Voici comment vous pouvez créer un agent GripTape personnalisé qui s'intègre au framework Swarms en héritant de la classe Agent dans Swarms et en remplacement de la méthode run(task: str) -> str .

 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 )

Composants clés:

1. GripTapeswarmsagent : une classe personnalisée qui hérite de la classe SwarmsAgent et intègre l'agent GripTape.
2. Exécuter (tâche: str) -> Str : Une méthode qui prend une chaîne de tâche, la traite (par exemple, la division d'une URL et un nom de fichier) et exécute l'agent GripTape avec les entrées fournies.
3. Outils GripTapape : Les outils intégrés dans l'agent GripTape (par exemple, WebScraperTool , PromptSummaryTool , FileManagerTool ) permettent de gratter, de résumé et de gestion des fichiers.

Vous pouvez désormais brancher facilement cet agent Griptape personnalisé dans le cadre Swarms et l'utiliser pour exécuter des tâches!

Comprendre les essaims

Qu'est-ce qu'un essaim?

Un essaim fait référence à un groupe de plus de deux agents travaillant en collaboration pour atteindre un objectif commun. Ces agents peuvent être des entités logicielles, telles que les LLM qui interagissent entre elles pour effectuer des tâches complexes. Le concept d'un essaim est inspiré par des systèmes naturels comme les colonies de fourmis ou les troupeaux d'oiseaux, où des comportements individuels simples conduisent à une dynamique de groupe complexe et à des capacités de résolution de problèmes.

Comment les architectures d'essaims facilitent la communication

Les architectures d'essaims sont conçues pour établir et gérer la communication entre les agents dans un essaim. Ces architectures définissent comment les agents interagissent, partagent des informations et coordonnent leurs actions pour atteindre les résultats souhaités. Voici quelques aspects clés des architectures d'essaims:

1. Communication hiérarchique : Dans les essaims hiérarchiques, la communication passe des agents de niveau supérieur aux agents de niveau inférieur. Les agents de niveau supérieur agissent en tant que coordinateurs, distribuant des tâches et agrégeant les résultats. Cette structure est efficace pour les tâches qui nécessitent un contrôle et une prise de décision descendants.

2. Communication parallèle : Dans les essaims parallèles, les agents fonctionnent indépendamment et communiquent entre eux au besoin. Cette architecture convient aux tâches qui peuvent être traitées simultanément sans dépendances, permettant une exécution et une évolutivité plus rapides.

3. Communication séquentielle : les tâches de processus séquentielles dans un ordre linéaire, où la sortie de chaque agent devient l'entrée de l'agent suivant. Cela garantit que les tâches avec les dépendances sont gérées dans la séquence correcte, en maintenant l'intégrité du flux de travail.

4. Communication en maillage : Dans les essaims de maillage, les agents sont entièrement connectés, permettant à tout agent de communiquer avec tout autre agent. Cette configuration offre une flexibilité et une redondance élevées, ce qui le rend idéal pour les systèmes complexes nécessitant des interactions dynamiques.

5. Communication fédérée : les essaims fédérés impliquent plusieurs essaims indépendants qui collaborent en partageant des informations et des résultats. Chaque essaim fonctionne de manière autonome mais peut contribuer à une tâche plus grande, permettant la résolution de problèmes distribués sur différents nœuds.

Les architectures d'essaims tirent parti de ces modèles de communication pour s'assurer que les agents travaillent efficacement, en s'adaptant aux exigences spécifiques de la tâche à accomplir. En définissant des protocoles de communication clairs et des modèles d'interaction, les architectures d'essaims permettent l'orchestration transparente de plusieurs agents, conduisant à des performances améliorées et à des capacités de résolution de problèmes.

Nom	Description	Lien de code	Cas d'utilisation
Essaims hiérarchiques	Un système où les agents sont organisés dans une hiérarchie, avec des agents de niveau supérieur coordonnant les agents de niveau inférieur pour obtenir des tâches complexes.	Lien de code	Optimisation des processus de fabrication, gestion des ventes à plusieurs niveaux, coordination des ressources de la santé
Agent réorganiser	Une configuration où les agents se réorganisent dynamiquement en fonction des exigences de la tâche et des conditions environnementales.	Lien de code	Lignes de fabrication adaptatives, réalignement du territoire des ventes dynamiques, dotation de santé flexible
Flux de travail simultanés	Les agents effectuent des tâches différentes simultanément, en coordonnant pour atteindre un objectif plus important.	Lien de code	Lignes de production simultanées, opérations de vente parallèle, processus de soins aux patients simultanés
Coordination séquentielle	Les agents effectuent des tâches dans une séquence spécifique, où l'achèvement d'une tâche déclenche le début de la suivante.	Lien de code	Chaînes de montage étape par étape, processus de vente séquentiels, flux de travail de traitement par étapes
Traitement parallèle	Les agents travaillent sur différentes parties d'une tâche simultanément pour accélérer le processus global.	Lien de code	Traitement des données parallèles dans la fabrication, analyse des ventes simultanées, tests médicaux simultanés
Mélange d'agents	Un essaim hétérogène où les agents dotés de capacités différentes sont combinés pour résoudre des problèmes complexes.	Lien de code	Prévision financière, résolution de problèmes complexes nécessitant des compétences diverses
Flux de travail graphique	Les agents collaborent dans un format de graphique acyclique dirigé (DAG) pour gérer les dépendances et les tâches parallèles.	Lien de code	Pipelines de développement de logiciels dirigés par l'IA, gestion de projet complexe
Chat de groupe	Les agents s'engagent dans une interaction semblable à un chat pour prendre des décisions en collaboration.	Lien de code	Prise de décision collaborative en temps réel, négociations contractuelles
Registre des agents	Un registre centralisé où les agents sont stockés, récupérés et invoqués dynamiquement.	Lien de code	Gestion des agents dynamiques, moteurs de recommandation en évolution
Essaim de feuille de calcul	Gère les tâches à grande échelle, le suivi des sorties de l'agent dans un format structuré comme les fichiers CSV.	Lien de code	Analyse marketing à grande échelle, audits financiers
Essaim de forêt	Une structure d'essaim qui organise des agents dans une hiérarchie en forme d'arbre pour les processus de prise de décision complexes.	Lien de code	Flux de travail à plusieurs étages, apprentissage du renforcement hiérarchique
Routeur d'essaim	Les voies et choisissent l'architecture d'essaims en fonction des exigences de la tâche et des agents disponibles.	Lien de code	Route de tâches dynamique, sélection de l'architecture d'essaim adaptative, allocation d'agent optimisée

SequentialWorkflow

Le workflow séquentiel vous permet d'exécuter séquentiellement des tâches avec Agent , puis de passer la sortie dans l'agent suivant et de surmonter jusqu'à ce que vous ayez spécifié vos boucles maximales.

 graphique LR
    A [agent 1] -> b [agent 2]
    B -> c [agent 3]
    C -> d [agent 4]
    D -> e [boucles max]
    E -> f [fin]

Méthodes

Méthode	Description	Paramètres	Valeur de retour
__init__	Initialiser le flow SequentialWork	agents : Liste des objets d'agent max_loops : nombre maximum d'itérations verbose : booléen pour la sortie verbale	Aucun
run	Exécuter le workflow	input_data : entrée initiale pour le premier agent	Sortie finale après que tous les agents ont traité

Entrées

Saisir	Taper	Description
agents	Liste [agent]	Liste des objets d'agent à exécuter séquentiellement
max_loops	int	Nombre maximum de fois toute la séquence sera répétée
verbose	bool	Si c'est vrai, imprimez des informations détaillées pendant l'exécution

Sortir

La méthode run renvoie la sortie finale après que tous les agents aient traité l'entrée séquentiellement.

Dans cet exemple, chaque Agent représente une tâche exécutée séquentiellement. La sortie de chaque agent est transmise à l'agent suivant dans la séquence jusqu'à ce que le nombre maximum de boucles soit atteint. Ce flux de travail est particulièrement utile pour les tâches qui nécessitent une série d'étapes à exécuter dans un ordre spécifique, telles que les pipelines de traitement des données ou les calculs complexes qui reposent sur la sortie des étapes précédentes.

 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

La technique d'orchestration AgentRearrange , inspirée d'Einops et d'Einsum, vous permet de définir et de cartographier les relations entre divers agents. Il fournit un outil puissant pour orchestrer des workflows complexes, vous permettant de spécifier des relations linéaires et séquentielles telles que a -> a1 -> a2 -> a3 , ou des relations simultanées où le premier agent envoie un message à 3 agents simultanément: a -> a1, a2, a3 . Ce niveau de personnalisation permet la création de flux de travail très efficaces et dynamiques, où les agents peuvent fonctionner en parallèle ou en séquence au besoin. La technique AgentRearrange est un ajout précieux à la bibliothèque Swarms, offrant un nouveau niveau de flexibilité et de contrôle sur l'orchestration des agents. Pour des informations et des exemples plus détaillés, veuillez vous référer à la documentation officielle.

Méthodes

Méthode	Description	Paramètres	Valeur de retour
__init__	Initialiser l'agentarrange	agents : Liste des objets d'agent flow : chaîne décrivant le flux d'agent	Aucun
run	Exécuter le workflow	input_data : entrée initiale pour le premier agent	Sortie finale après que tous les agents ont traité

Entrées

Saisir	Taper	Description
agents	Liste [agent]	Liste des objets d'agent à orchestrer
flow	Str	Chaîne décrivant le flux d'agents (par exemple, "a -> b, c")

Sortir

La méthode run renvoie la sortie finale après que tous les agents aient traité l'entrée en fonction du flux spécifié.

 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

À venir...

GraphSwarm

Le GraphSwarm est un système de gestion du flux de travail conçu pour orchestrer les tâches complexes en tirant parti de la puissance de la théorie des graphiques. Il permet à la création d'un graphique acyclique dirigé (DAG) de modéliser les dépendances entre les tâches et les agents. Cela permet une affectation, une exécution et une surveillance efficaces.

Voici une ventilation du fonctionnement du GraphSwarm :

1. Création de nœuds : le flux de travail GraphSwarm est composé de nœuds, qui peuvent être des agents ou des tâches. Les agents sont responsables de l'exécution de tâches et les tâches représentent des opérations spécifiques qui doivent être effectuées. Dans l'exemple, deux agents ( agent1 et agent2 ) et une tâche ( task1 ) sont créés.
2. Définition du bord : les bords sont utilisés pour définir les relations entre les nœuds. Dans ce cas, des bords sont créés pour connecter agent1 et agent2 à task1 , indiquant que les deux agents sont capables d'exécuter task1 .
3. Entrée et points finaux : le flux de travail GraphSwarm nécessite la définition des points d'entrée (où le flux de travail commence) et les points finaux (où le flux de travail se termine). Dans cet exemple, agent1 et agent2 sont définis en tant que points d'entrée, et task1 est défini comme point final.
4. Visualisation : Le GraphSwarm fournit une fonctionnalité de visualisation pour représenter graphiquement le flux de travail. Cela permet une compréhension et un débogage faciles de la structure du flux de travail.
5. Exécution : le flux de travail GraphSwarm est exécuté en traversant le graphique des points d'entrée aux points finaux. Dans ce cas, agent1 et agent2 exécutent simultanément task1 et les résultats sont collectés.
6. Résultats : Les résultats finaux de l'exécution du flux de travail sont agrégés et retournés. Dans cet exemple, le résultat de l'exécution task1 est "Tâche terminée".

Le GraphSwarm offre plusieurs avantages, notamment:

• Concurrence : permet l'exécution des tâches simultanément, en améliorant l'efficacité globale du flux de travail.
• Flexibilité : permet une affectation de tâches dynamique en fonction de la disponibilité des agents et des exigences des tâches.
• Évolutivité : prend en charge l'ajout de nouveaux agents et tâches au besoin, ce qui le rend adapté aux workflows à grande échelle.
• Visualisation : fournit une représentation graphique du flux de travail, facilitant la compréhension et le débogage.

En tirant parti du GraphSwarm , les workflows complexes peuvent être gérés efficacement et les tâches peuvent être exécutées de manière coordonnée et évolutive.

Méthodes

Méthode	Description	Paramètres	Valeur de retour
add_node	Ajouter un nœud au graphique	node : objet de nœud	Aucun
add_edge	Ajouter un bord au graphique	edge : objet de bord	Aucun
set_entry_points	Définissez les points d'entrée du graphique	entry_points : liste des ID de nœud	Aucun
set_end_points	Définissez les points finaux du graphique	end_points : liste des ID de nœud	Aucun
visualize	Générer une représentation visuelle du graphique	Aucun	Représentation de cordes du graphique
run	Exécuter le workflow	Aucun	Résultats du dictionnaire d'exécution

Entrées

Saisir	Taper	Description
Node	Objet	Représente un nœud dans le graphique (agent ou tâche)
Edge	Objet	Représente un bord reliant deux nœuds
entry_points	Liste [Str]	Liste des ID de nœud où commence le flux de travail
end_points	Liste [Str]	Liste des ID de nœud où se termine le flux de travail

Sortir

La méthode run renvoie un dictionnaire contenant les résultats d'exécution de tous les nœuds du graphique.

 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

Il s'agit d'une implémentation basée sur l'article: "Le mélange-d'agents améliore les capacités du modèle de langue grande" de Together.ai, disponible sur https://arxiv.org/abs/2406.04692. Il obtient des résultats à la pointe de la technologie (SOTA) sur Alpacaeval 2.0, MT-Bench et Flask, dépassant GPT-4 OMNI. Cette architecture convient particulièrement aux tâches qui nécessitent une parallélisation suivie d'un traitement séquentiel dans une autre boucle.

Méthodes

Méthode	Description	Paramètres	Valeur de retour
__init__	Initialiser le mélange de biens	name : nom de l'essaim agents : Liste des objets d'agent layers : nombre de couches de traitement final_agent : agent pour le traitement final	Aucun
run	Exécuter l'essaim	task : tâche d'entrée pour l'essaim	Sortie finale après que tous les agents ont traité

Entrées

Saisir	Taper	Description
name	Str	Nom de l'essaim
agents	Liste [agent]	Liste des objets d'agent à utiliser dans l'essaim
layers	int	Nombre de couches de traitement dans l'essaim
final_agent	Agent	Agent responsable du traitement final

Sortir

La méthode run renvoie la sortie finale après que tous les agents aient traité l'entrée en fonction des couches spécifiées et de l'agent final.

 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 )

Arme de calcul

Le SpreadSheetSwarm est conçu pour la gestion simultanée et la surveillance de milliers d'agents, facilitant une approche un-à-plusieurs pour un traitement efficace des tâches et une analyse de sortie.

Caractéristiques clés

• Concurrence : permet l'exécution simultanée de plusieurs agents, réduisant considérablement le temps de traitement et augmentant l'efficacité globale du système.
• One-à-plusieurs : permet à une seule tâche d'être distribuée dynamiquement entre plusieurs agents, garantissant que chaque agent est utilisé à son plein potentiel.
• Évolutivité : soutient l'intégration de milliers d'agents, ce qui en fait une solution idéale pour le traitement des tâches à grande échelle et l'analyse des données.

Méthodes

Méthode	Description	Paramètres	Valeur de retour
__init__	Initialiser le sweat-sweet	name : nom de l'essaim description : Description de l'essaim agents : Liste des objets d'agent autosave_on : Boolean pour permettre à Autosave save_file_path : chemin pour sauver la feuille de calcul run_all_agents : booléen pour gérer tous les agents ou non max_loops : nombre maximum de boucles	Aucun
run	Exécuter l'essaim	task : tâche d'entrée pour l'essaim	Dictionnaire des sorties d'agent

Entrées

Saisir	Taper	Description
name	Str	Nom de l'essaim
description	Str	Description du but de l'essaim
agents	Liste [agent]	Liste des objets d'agent à utiliser dans l'essaim
autosave_on	bool	Activer la sauvegarde automatique des résultats
save_file_path	Str	Chemin pour sauver les résultats de la feuille de calcul
run_all_agents	bool	Que ce soit pour exécuter tous les agents ou sélectionner en fonction de la pertinence
max_loops	int	Nombre maximum de boucles de traitement

Sortir

La méthode run renvoie un dictionnaire contenant les sorties de chaque agent qui a traité la tâche.

En savoir plus sur les documents ici:

 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

L'architecture ForestSwarm est conçue pour une affectation de tâches efficace en sélectionnant dynamiquement l'agent le plus approprié dans une collection d'arbres. Ceci est réalisé grâce au traitement des tâches asynchrones, où les agents sont choisis en fonction de leur pertinence pour la tâche à accomplir. La pertinence est déterminée en calculant la similitude entre les invites du système associées à chaque agent et les mots clés présents dans la tâche elle-même. Pour une compréhension plus approfondie du fonctionnement ForestSwarm , veuillez vous référer à la documentation officielle.

Méthodes

Méthode	Description	Paramètres	Valeur de retour
__init__	Initialiser le gratte	trees : liste des objets d'arbres	Aucun
run	Exécuter le gratte forêt	task : tâche d'entrée pour l'essaim	Sortie de l'agent le plus pertinent

Entrées

Saisir	Taper	Description
trees	Liste [arbre]	Liste des objets d'arbre, chacun contenant des objets TreeAgent
task	Str	La tâche à traiter par le swarm forestier

Sortir

La méthode run renvoie la sortie de l'agent le plus pertinent sélectionné en fonction de la tâche d'entrée.

 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

La classe SwarmRouter est un système de routage flexible conçu pour gérer différents types d'essaims pour l'exécution des tâches. Il fournit une interface unifiée pour interagir avec divers types d'essaims, notamment AgentRearrange , MixtureOfAgents , SpreadSheetSwarm , SequentialWorkflow et ConcurrentWorkflow . Nous ajouterons en permanence de plus en plus d'architectures d'essaims ici à mesure que nous progressons avec de nouvelles architectures.

Attributs:

• name (Str): Nom de l'instance Swarmrouter.
• description (Str): Description de l'instance Swarmrouter.
• max_loops (INT): Nombre maximum de boucles à effectuer.
• agents (List [Agent]): Liste des objets d'agent à utiliser dans l'essaim.
• swarm_type (SwarmType): type d'essaim à utiliser.
• swarm (Union [AGENTARAGE, Mélange de biens, arme de calcul, SequentialWorkFlow, ConcurrentWorkFlow]): objet Swarm instancié.
• logs (liste [Swarmlog]): liste des entrées de journal capturées pendant les opérations.

Méthodes:

• __init__(self, name: str, description: str, max_loops: int, agents: List[Agent], swarm_type: SwarmType, *args, **kwargs) : initialisez le Swarmrouter.
• _create_swarm(self, *args, **kwargs) : créez et renvoyez le type d'essaim spécifié.
• _log(self, level: str, message: str, task: str, metadata: Dict[str, Any]) : créez une entrée de journal et ajoutez-le à la liste des journaux.
• run(self, task: str, *args, **kwargs) : exécutez la tâche spécifiée sur l'essaim sélectionné.
• get_logs(self) : récupérer toutes les entrées enregistrées.

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

Changer les types d'essaims

Vous pouvez créer plusieurs instances Swarmrouter avec différents types d'essaims:

 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
)

Agencement

Cas d'utilisation: Optimisation de l'ordre des agents pour des tâches complexes en plusieurs étapes.

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

Mélanges

Cas d'utilisation: combiner divers agents experts pour une analyse complète.

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

---

Session d'intégration

Soyez à bord maintenant avec le créateur et le mainteneur principal de Swarms, Kye Gomez, qui vous montrera comment démarrer avec l'installation, des exemples d'utilisation et commencer à créer votre cas d'utilisation personnalisé! CLIQUEZ ICI

---

Documentation

La documentation est située ici à: docs.swarms.world

---

Structure de dossier

L'ensemble Swarms a été métiLEXILEMENT conçu swarms.structs une utilisation et une compréhension extrêmes, Agent package Swarms est divisé en divers modules tels que swarms.agents qui contient Structures d'agent. Les 3 les plus importants sont structs , models et agents .

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

---

? Contributions:

La façon la plus simple de contribuer est de choisir un problème avec la good first issue ?. Lisez les directives contributives ici. Rapport de bug? Fichier ici | Demande de fonctionnalité? Dossier ici

Swarms est un projet open-source et les contributions sont les bienvenues. Si vous souhaitez contribuer, vous pouvez créer de nouvelles fonctionnalités, corriger les bogues ou améliorer l'infrastructure. Veuillez vous référer à la contribution.md et à notre comité de contribution pour participer aux discussions de la feuille de route!

---

Accélérer le arriéré

Accélérez les bogues, les fonctionnalités et les démos à implémenter en nous soutenant ici:

Communauté

Rejoignez notre communauté croissante dans le monde entier, pour un soutien en temps réel, des idées et des discussions sur les essaims?

• Voir notre blog officiel
• Chat en direct avec nous sur Discord
• Suivez-nous sur Twitter
• Connectez-vous avec nous sur LinkedIn
• Visitez-nous sur YouTube
• Rejoignez la communauté Swarms sur Discord!
• Rejoignez notre rassemblement communautaire Swarms tous les jeudis à 13 heures, heure de New York, pour débloquer le potentiel des agents autonomes pour automatiser vos tâches quotidiennes

Licence

Licence publique générale de GNU Affero