swarms

El marco de orquestación de agentes múltiples listos para la producción de grado empresarial

? Twitter • ? Discord • Swarms Platform • ? Documentación

Características

Categoría	Características	Beneficios
? Arquitectura empresarial	• Infraestructura lista para la producción • Sistemas de alta fiabilidad • Diseño modular • Registro integral	• Tiempo de inactividad reducido • Mantenimiento más fácil • Mejor depuración • Monitoreo mejorado
? Orquestación del agente	• Enjambres jerárquicos • Procesamiento paralelo • Flujos de trabajo secuenciales • Flujos de trabajo basados ​​en gráficos • Reordenamiento del agente dinámico	• Manejo de tareas complejas • rendimiento mejorado • Flujos de trabajo flexibles • Ejecución optimizada
Capacidades de integración	• Soporte multimodelo • Creación de agentes personalizados • extensa biblioteca de herramientas • Múltiples sistemas de memoria	• Flexibilidad del proveedor • Soluciones personalizadas • Funcionalidad extendida • Gestión de memoria mejorada
? Escalabilidad	• Procesamiento concurrente • Gestión de recursos • Equilibrio de carga • Escala horizontal	• Mayor rendimiento • Uso eficiente de recursos • Mejor rendimiento • Escalado fácil
Herramientas para desarrolladores	• API simple • Documentación extensa • Comunidad activa • Herramientas de CLI	• Desarrollo más rápido • Curva de aprendizaje fácil • Apoyo a la comunidad • Implementación rápida
? Características de seguridad	• Manejo de errores • Limitar la tasa • Monitoreo de integración • Registro de auditorías	• Confiabilidad mejorada • Protección de API • Mejor monitoreo • Seguimiento mejorado
Características avanzadas	• hojas de cálculo • Chat grupal • Registro de agentes • Mezcla de agentes	• Gestión de agentes masivos • AI colaborativa • Control centralizado • Soluciones complejas
? Soporte de proveedores	• Openai • antrópico • ChromadB • Proveedores personalizados	• Flexibilidad del proveedor • Opciones de almacenamiento • Integración personalizada • Independencia del proveedor
? Características de producción	• Vueltos automáticos • Soporte de async • Gestión del medio ambiente • Tipo de seguridad	• Mejor confiabilidad • rendimiento mejorado • Configuración fácil • Código más seguro
Soporte de casos de uso	• Agentes específicos de la tarea • Flujos de trabajo personalizados • Soluciones de la industria • Marco extensible	• Implementación rápida • Soluciones flexibles • preparación de la industria • Personalización fácil

---

Requisitos

• python3.10 or above!
• $ pip install -U swarms And, don't forget to install swarms!
• .env file with API keys from your providers like OPENAI_API_KEY , ANTHROPIC_API_KEY
• Set an .env Variable with your desired workspace dir: WORKSPACE_DIR="agent_workspace" or do it in your terminal with export WORKSPACE_DIR="agent_workspace"
• Finally, swarms onboarding to get you started.

Guías y tutoriales

Consulte nuestra documentación para los detalles de implementación de grado de producción.

Sección	Campo de golf
Instalación	Instalación
Inicio rápido	Empezar
Mecanismos internos del agente	Arquitectura de agente
Agente API	Agente API
Integración de agentes externos Grotape, Autógeno, etc.	Integrando API externas
Creando agentes de Yaml	Creando agentes de Yaml
Por qué necesitas enjambres	Por qué es necesaria la colaboración multiagente
Análisis de arquitecturas de enjambre	Arquitecturas de enjambre
Elegir el enjambre adecuado para su problema comercialin	HAGA CLIC AQUÍ
Docs de AgentRearrange	HAGA CLIC AQUÍ

Instalar

$ pip3 install -U swarms

Incorporación

Now that you have downloaded swarms with pip3 install -U swarms , we get access to the CLI . Ponte a bordo con CLI ahora con:

swarms onboarding

También puede ejecutar este comando para obtener ayuda:

swarms help

Para obtener más documentación sobre la CLI, haga clic aquí

---

¿Ejemplos de uso?

Aquí hay algunos scripts de ejemplo para comenzar. Para una documentación más completa, visite nuestros documentos.

Nombre de ejemplo	Descripción	Tipo de ejemplos	Enlace
Ejemplos de enjambres	Una colección de ejemplos simples para demostrar capacidades de enjambres.	Uso básico	https://github.com/the-swarm-corporation/swarms-examples?tab=readme-ov-file
Libro de cocina	Una guía completa con recetas para varios casos de uso y escenarios.	Uso avanzado	https://github.com/the-swarm-corporation/cookbook

---

Agent Class

The Agent class is a fundamental component of the Swarms framework, designed to execute tasks autonomously. Fusiona LLMS, herramientas y capacidades de memoria a largo plazo para crear un agente de pila completo. The Agent class is highly customizable, allowing for fine-grained control over its behavior and interactions.

run Method

The run method is the primary entry point for executing tasks with an Agent instance. Acepta una cadena de tareas como la tarea de entrada principal y la procesa de acuerdo con la configuración del agente. And, it can also accept an img parameter such as img="image_filepath.png to process images if you have a VLM

Configuración y personalización

The Agent class offers a range of settings to tailor its behavior to specific needs. Algunas configuraciones de clave incluyen:

Configuración	Descripción	Valor predeterminado
agent_name	El nombre del agente.	"DefaultAgent"
system_prompt	El sistema solicita usar para el agente.	"Solicitud de sistema predeterminada".
llm	El modelo de idioma se utilizará para las tareas de procesamiento.	OpenAIChat instance
max_loops	El número máximo de bucles para ejecutar para una tarea.	1
autosave	Habilita o deshabilita el ahorro del estado del agente.	FALSO
dashboard	Habilita o deshabilita el tablero para el agente.	FALSO
verbose	Controla la verbosidad de la salida del agente.	FALSO
dynamic_temperature_enabled	Habilita o deshabilita el ajuste de temperatura dinámica para el modelo de lenguaje.	FALSO
saved_state_path	El camino para salvar el estado del agente.	"agent_state.json"
user_name	El nombre de usuario asociado con el agente.	"default_user"
retry_attempts	El número de intentos de reintento para tareas fallidas.	1
context_length	La longitud máxima del contexto a considerar para las tareas.	200000
return_step_meta	Controla si devolver metadatos de paso en la salida.	FALSO
output_type	El tipo de salida para return (por ejemplo, "json", "cadena").	"cadena"

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

---

Integrar el trapo con enjambres para una memoria mejorada a largo plazo

Agent equipped with quasi-infinite long term memory using RAG (Relational Agent Graph) for advanced document understanding, analysis, and retrieval capabilities.

Diagrama de sirena para la integración del trapo

 Gráfico TD
    A [Inicializar agente con RAG] -> B [Tarea de recibir]
    B-> C [Memoria a largo plazo de consulta]
    C -> D [Tarea de proceso con contexto]
    D -> E [Generar respuesta]
    E-> F [Actualizar memoria a largo plazo]
    F -> G [Salida de retorno]

Paso 1: Inicializar el cliente 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
)

Paso 2: Defina el modelo

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

Paso 3: Inicializa el agente con trapo

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

---

Configuración del agente misceláneo

Proporcionamos una amplia gama de características para salvar los estados de agentes utilizando JSON, YAML, TOML, Subir PDF, trabajos por lotes y mucho más.

Tabla de métodos

Método	Descripción
to_dict()	Convierte el objeto del agente a un diccionario.
to_toml()	Convierte el objeto del agente a una cadena Toml.
model_dump_json()	Volcar el modelo a un archivo JSON.
model_dump_yaml()	Volcar el modelo a un archivo YAML.
ingest_docs()	Ingere documentos en la base de conocimiento del agente.
receive_message()	Recibe un mensaje de un usuario y lo procesa.
send_agent_message()	Envía un mensaje del agente a un usuario.
filtered_run()	Ejecuta el agente con una solicitud de sistema filtrado.
bulk_run()	Ejecuta el agente con múltiples indicaciones del sistema.
add_memory()	Agrega una memoria al agente.
check_available_tokens()	Comprueba el número de tokens disponibles para el agente.
tokens_checks()	Realiza controles de token para el agente.
print_dashboard()	Imprime el tablero del agente.
get_docs_from_doc_folders()	Obtiene todos los documentos de las carpetas DOC.
activate_agentops()	Activa las operaciones del agente.
check_end_session_agentops()	Comprueba el final de la sesión para las operaciones de agentes.

 # # 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 with Pydantic BaseModel as Output Type

El siguiente es un ejemplo de un agente que ingiere un basemodelo pydantic y lo genera al mismo tiempo:

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

Agente autónomo múltiple

Ejecute el agente con múltiples modalidades útiles para varias tareas del mundo real en fabricación, logística y salud.

 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 es un agente que puede usar herramientas a través de llamadas de funciones JSON. Influye cualquier modelo de código abierto desde Huggingface y es extremadamente modular y enchufa y reproduce. Necesitamos ayuda para agregar soporte general a todos los modelos pronto.

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

Integrando agentes externos

La integración de agentes externos de otros marcos de agentes es fácil con los enjambres.

Pasos:

1. Create a new class that inherits Agent
2. Create a .run(task: str) -> str method that runs the agent and returns the response.
3. El nuevo agente debe devolver una cadena de la respuesta. Pero puede agregar métodos adicionales para guardar la salida a JSON.

Ejemplo

Por ejemplo, aquí hay un ejemplo sobre cómo crear un agente de Griptape.

Here's how you can create a custom Griptape agent that integrates with the Swarms framework by inheriting from the Agent class in Swarms and overriding the run(task: str) -> str method.

 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 )

Componentes clave:

1. GriptapeSwarmsAgent : A custom class that inherits from the SwarmsAgent class and integrates the Griptape agent.
2. run(task: str) -> str : A method that takes a task string, processes it (eg, splitting into a URL and filename), and runs the Griptape agent with the provided inputs.
3. Griptape Tools : The tools integrated into the Griptape agent (eg, WebScraperTool , PromptSummaryTool , FileManagerTool ) allow for web scraping, summarization, and file management.

You can now easily plug this custom Griptape agent into the Swarms Framework and use it to run tasks!

Comprender los enjambres

¿Qué es un enjambre?

Un enjambre se refiere a un grupo de más de dos agentes que trabajan en colaboración para lograr un objetivo común. Estos agentes pueden ser entidades de software, como LLM que interactúan entre sí para realizar tareas complejas. El concepto de un enjambre está inspirado en sistemas naturales como colonias de hormigas o bandadas de aves, donde los comportamientos individuales simples conducen a una dinámica de grupo compleja y capacidades de resolución de problemas.

Cómo las arquitecturas de enjambre facilitan la comunicación

Las arquitecturas de enjambre están diseñadas para establecer y gestionar la comunicación entre agentes dentro de un enjambre. Estas arquitecturas definen cómo los agentes interactúan, comparten información y coordinan sus acciones para lograr los resultados deseados. Aquí hay algunos aspectos clave de las arquitecturas de enjambre:

1. Hierarchical Communication : In hierarchical swarms, communication flows from higher-level agents to lower-level agents. Los agentes de nivel superior actúan como coordinadores, distribuyen tareas y agregan resultados. Esta estructura es eficiente para tareas que requieren control de arriba hacia abajo y toma de decisiones.

2. Parallel Communication : In parallel swarms, agents operate independently and communicate with each other as needed. Esta arquitectura es adecuada para tareas que se pueden procesar simultáneamente sin dependencias, lo que permite una ejecución y escalabilidad más rápidas.

3. Sequential Communication : Sequential swarms process tasks in a linear order, where each agent's output becomes the input for the next agent. Esto asegura que las tareas con las dependencias se manejen en la secuencia correcta, manteniendo la integridad del flujo de trabajo.

4. Mesh Communication : In mesh swarms, agents are fully connected, allowing any agent to communicate with any other agent. Esta configuración proporciona una alta flexibilidad y redundancia, lo que lo hace ideal para sistemas complejos que requieren interacciones dinámicas.

5. Federated Communication : Federated swarms involve multiple independent swarms that collaborate by sharing information and results. Cada enjambre opera de forma autónoma, pero puede contribuir a una tarea más grande, lo que permite la resolución de problemas distribuidas en diferentes nodos.

Las arquitecturas de enjambre aprovechan estos patrones de comunicación para garantizar que los agentes trabajen juntos de manera eficiente, adaptándose a los requisitos específicos de la tarea en cuestión. Al definir protocolos de comunicación y modelos de interacción claros, las arquitecturas de enjambre permiten la orquestación perfecta de múltiples agentes, lo que lleva a un mayor rendimiento y capacidades de resolución de problemas.

Nombre	Descripción	Enlace de código	Casos de uso
Enjambres jerárquicos	Un sistema donde los agentes se organizan en una jerarquía, con agentes de nivel superior que coordinan a los agentes de nivel inferior para lograr tareas complejas.	Enlace de código	Optimización de procesos de fabricación, gestión de ventas multinivel, coordinación de recursos de salud
Agente reorganizar	Una configuración en la que los agentes se reorganizan dinámicamente en función de los requisitos de la tarea y las condiciones ambientales.	Enlace de código	Líneas de fabricación adaptativa, realineación de territorio de ventas dinámico, personal de atención médica flexible
Flujos de trabajo concurrentes	Los agentes realizan diferentes tareas simultáneamente, coordinando para completar un objetivo más grande.	Enlace de código	Líneas de producción concurrentes, operaciones de ventas paralelas, procesos simultáneos de atención al paciente
Coordinación secuencial	Los agentes realizan tareas en una secuencia específica, donde la finalización de una tarea desencadena el inicio de la siguiente.	Enlace de código	Líneas de ensamblaje paso a paso, procesos de ventas secuenciales, flujos de trabajo de tratamiento de pacientes paso a paso
Procesamiento paralelo	Los agentes trabajan en diferentes partes de una tarea simultáneamente para acelerar el proceso general.	Enlace de código	Procesamiento de datos paralelos en fabricación, análisis de ventas simultáneas, pruebas médicas concurrentes
Mezcla de agentes	Un enjambre heterogéneo donde los agentes con diferentes capacidades se combinan para resolver problemas complejos.	Enlace de código	Pronóstico financiero, resolución compleja de problemas que requieren diversas habilidades
Flujo de trabajo gráfico	Los agentes colaboran en un formato de gráfico acíclico dirigido (DAG) para administrar dependencias y tareas paralelas.	Enlace de código	Tuberías de desarrollo de software impulsado por IA, gestión de proyectos complejos
Chat grupal	Los agentes participan en una interacción con forma de chat para alcanzar decisiones en colaboración.	Enlace de código	Toma de decisiones colaborativas en tiempo real, negociaciones por contrato
Registro de agentes	Un registro centralizado donde los agentes se almacenan, se recuperan e invocan dinámicamente.	Enlace de código	Gestión de agentes dinámicos, motores de recomendación en evolución
Enjambre de hoja de cálculo	Administra tareas a escala, rastreando salidas de agentes en un formato estructurado como archivos CSV.	Enlace de código	Análisis de marketing a gran escala, auditorías financieras
Enjambre del bosque	Una estructura de enjambre que organiza a los agentes en una jerarquía similar a un árbol para procesos complejos de toma de decisiones.	Enlace de código	Flujos de trabajo de varias etapas, aprendizaje de refuerzo jerárquico
Enjambre	Rutas y elige la arquitectura del enjambre basada en los requisitos de la tarea y los agentes disponibles.	Enlace de código	Enrutamiento de tareas dinámicas, selección de arquitectura de enjambre adaptativa, asignación de agentes optimizados

SequentialWorkflow

Sequential Workflow enables you to sequentially execute tasks with Agent and then pass the output into the next agent and onwards until you have specified your max loops.

 Gráfico LR
    A [Agente 1] -> B [Agente 2]
    B -> C [Agente 3]
    C -> D [Agente 4]
    D -> E [Max Loops]
    E -> f [fin]

Métodos

Método	Descripción	Parámetros	Valor de retorno
__init__	Inicializar el flujo de trabajo secuencial	agents : List of Agent objects max_loops : Maximum number of iterations verbose : Boolean for verbose output	Ninguno
run	Ejecutar el flujo de trabajo	input_data : Initial input for the first agent	Salida final después de que todos los agentes han procesado

Entradas

Aporte	Tipo	Descripción
agents	Lista [Agente]	Lista de objetos de agente que se ejecutarán secuencialmente
max_loops	intencionalmente	El número máximo de veces se repetirá toda la secuencia
verbose	bool	Si es cierto, imprima información detallada durante la ejecución

Producción

The run method returns the final output after all agents have processed the input sequentially.

In this example, each Agent represents a task that is executed sequentially. La salida de cada agente se pasa al siguiente agente en la secuencia hasta que se alcanza el número máximo de bucles. Este flujo de trabajo es particularmente útil para tareas que requieren una serie de pasos para ejecutarse en un orden específico, como tuberías de procesamiento de datos o cálculos complejos que se basan en la salida de pasos anteriores.

 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

The AgentRearrange orchestration technique, inspired by Einops and einsum, allows you to define and map out the relationships between various agents. It provides a powerful tool for orchestrating complex workflows, enabling you to specify linear and sequential relationships such as a -> a1 -> a2 -> a3 , or concurrent relationships where the first agent sends a message to 3 agents simultaneously: a -> a1, a2, a3 . Este nivel de personalización permite la creación de flujos de trabajo altamente eficientes y dinámicos, donde los agentes pueden trabajar en paralelo o en secuencia según sea necesario. The AgentRearrange technique is a valuable addition to the swarms library, providing a new level of flexibility and control over the orchestration of agents. Para obtener información y ejemplos más detallados, consulte la documentación oficial.

Métodos

Método	Descripción	Parámetros	Valor de retorno
__init__	Inicializar el agenteRearrange	agents : List of Agent objects flow : String describing the agent flow	Ninguno
run	Ejecutar el flujo de trabajo	input_data : Initial input for the first agent	Salida final después de que todos los agentes han procesado

Entradas

Aporte	Tipo	Descripción
agents	Lista [Agente]	Lista de objetos de agente para ser orquestados
flow	stri	Cadena que describe el flujo de agentes (por ejemplo, "A -> B, C")

Producción

The run method returns the final output after all agents have processed the input according to the specified flow.

 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

Muy pronto...

GraphSwarm

The GraphSwarm is a workflow management system designed to orchestrate complex tasks by leveraging the power of graph theory. Permite la creación de un gráfico acíclico dirigido (DAG) para modelar dependencias entre tareas y agentes. Esto permite una asignación de tareas eficiente, ejecución y monitoreo.

Here's a breakdown of how the GraphSwarm works:

1. Node Creation : The GraphSwarm workflow is composed of nodes, which can be either agents or tasks. Los agentes son responsables de ejecutar tareas, y las tareas representan operaciones específicas que deben realizarse. In the example, two agents ( agent1 and agent2 ) and one task ( task1 ) are created.
2. Edge Definition : Edges are used to define the relationships between nodes. In this case, edges are created to connect agent1 and agent2 to task1 , indicating that both agents are capable of executing task1 .
3. Entry and End Points : The GraphSwarm workflow requires the definition of entry points (where the workflow starts) and end points (where the workflow concludes). In this example, agent1 and agent2 are set as entry points, and task1 is set as the end point.
4. Visualization : The GraphSwarm provides a visualization feature to graphically represent the workflow. Esto permite una fácil comprensión y depuración de la estructura del flujo de trabajo.
5. Execution : The GraphSwarm workflow is executed by traversing the graph from the entry points to the end points. In this case, both agent1 and agent2 execute task1 concurrently, and the results are collected.
6. Results : The final results of the workflow execution are aggregated and returned. In this example, the result of executing task1 is "Task completed".

The GraphSwarm offers several benefits, including:

• Concurrency : Enables the execution of tasks concurrently, improving overall workflow efficiency.
• Flexibility : Allows for dynamic task assignment based on agent availability and task requirements.
• Scalability : Supports the addition of new agents and tasks as needed, making it suitable for large-scale workflows.
• Visualization : Provides a graphical representation of the workflow, facilitating understanding and debugging.

By leveraging the GraphSwarm , complex workflows can be efficiently managed, and tasks can be executed in a coordinated and scalable manner.

Métodos

Método	Descripción	Parámetros	Valor de retorno
add_node	Agregue un nodo al gráfico	node : Node object	Ninguno
add_edge	Agregue un borde al gráfico	edge : Edge object	Ninguno
set_entry_points	Establezca los puntos de entrada del gráfico	entry_points : List of node IDs	Ninguno
set_end_points	Establezca los puntos finales del gráfico	end_points : List of node IDs	Ninguno
visualize	Generar una representación visual del gráfico	Ninguno	Representación de cadena del gráfico
run	Ejecutar el flujo de trabajo	Ninguno	Diccionario de resultados de ejecución

Entradas

Aporte	Tipo	Descripción
Node	Objeto	Representa un nodo en el gráfico (agente o tarea)
Edge	Objeto	Representa un borde que conecta dos nodos
entry_points	Lista [STR]	Lista de ID de nodo donde comienza el flujo de trabajo
end_points	Lista [STR]	Lista de ID de nodo donde termina el flujo de trabajo

Producción

The run method returns a dictionary containing the execution results of all nodes in the graph.

 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

Esta es una implementación basada en el documento: "La mezcla de los agentes mejora las capacidades del modelo de idioma grandes" de Together.ai, disponible en https://arxiv.org/abs/2406.04692. Logra resultados de última generación (SOTA) en Alpacaeval 2.0, MT-Bench y Flask, superando a GPT-4 Omni. Esta arquitectura es particularmente adecuada para tareas que requieren paralelización seguida de un procesamiento secuencial en otro bucle.

Métodos

Método	Descripción	Parámetros	Valor de retorno
__init__	Inicializar las mezclas	name : Name of the swarm agents : List of Agent objects layers : Number of processing layers final_agent : Agent for final processing	Ninguno
run	Ejecutar el enjambre	task : Input task for the swarm	Salida final después de que todos los agentes han procesado

Entradas

Aporte	Tipo	Descripción
name	stri	Nombre del enjambre
agents	Lista [Agente]	Lista de objetos de agente que se utilizarán en el enjambre
layers	intencionalmente	Número de capas de procesamiento en el enjambre
final_agent	Agente	Agente responsable del procesamiento final

Producción

The run method returns the final output after all agents have processed the input according to the specified layers and final agent.

 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 )

Hojas de cálculo

The SpreadSheetSwarm is designed for concurrent management and oversight of thousands of agents, facilitating a one-to-many approach for efficient task processing and output analysis.

Características clave

• Concurrency : Enables the simultaneous execution of multiple agents, significantly reducing processing time and increasing overall system efficiency.
• One-to-Many : Allows a single task to be dynamically distributed among multiple agents, ensuring that each agent is utilized to its full potential.
• Scalability : Supports the integration of thousands of agents, making it an ideal solution for large-scale task processing and data analysis.

Métodos

Método	Descripción	Parámetros	Valor de retorno
__init__	Inicializar las hojas de cálculo	name : Name of the swarm description : Description of the swarm agents : List of Agent objects autosave_on : Boolean to enable autosave save_file_path : Path to save the spreadsheet run_all_agents : Boolean to run all agents or not max_loops : Maximum number of loops	Ninguno
run	Ejecutar el enjambre	task : Input task for the swarm	Diccionario de salidas de agentes

Entradas

Aporte	Tipo	Descripción
name	stri	Nombre del enjambre
description	stri	Descripción del propósito del enjambre
agents	Lista [Agente]	Lista de objetos de agente que se utilizarán en el enjambre
autosave_on	bool	Habilitar elaboración de autosaviones de los resultados
save_file_path	stri	Ruta para guardar los resultados de la hoja de cálculo
run_all_agents	bool	Si ejecutar todos los agentes o seleccionar según la relevancia
max_loops	intencionalmente	Número máximo de bucles de procesamiento

Producción

The run method returns a dictionary containing the outputs of each agent that processed the task.

Obtenga más información en los documentos aquí:

 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

The ForestSwarm architecture is designed for efficient task assignment by dynamically selecting the most suitable agent from a collection of trees. Esto se logra a través del procesamiento de tareas asincrónicas, donde los agentes se eligen en función de su relevancia para la tarea en cuestión. La relevancia se determina calculando la similitud entre las indicaciones del sistema asociadas con cada agente y las palabras clave presentes en la tarea misma. For a more in-depth understanding of how ForestSwarm works, please refer to the official documentation.

Métodos

Método	Descripción	Parámetros	Valor de retorno
__init__	Inicializar el acelerador forestal	trees : List of Tree objects	Ninguno
run	Ejecutar el flujo de bosque	task : Input task for the swarm	Salida del agente más relevante

Entradas

Aporte	Tipo	Descripción
trees	Lista [Árbol]	Lista de objetos de árbol, cada uno que contiene objetos Treeagent
task	stri	La tarea que debe procesar el flujo de bosque

Producción

The run method returns the output from the most relevant agent selected based on the input task.

 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

The SwarmRouter class is a flexible routing system designed to manage different types of swarms for task execution. It provides a unified interface to interact with various swarm types, including AgentRearrange , MixtureOfAgents , SpreadSheetSwarm , SequentialWorkflow , and ConcurrentWorkflow . Agregaremos continuamente más y más arquitecturas de enjambre aquí a medida que avanzamos con nuevas arquitecturas.

Atributos:

• name (str): Name of the SwarmRouter instance.
• description (str): Description of the SwarmRouter instance.
• max_loops (int): Maximum number of loops to perform.
• agents (List[Agent]): List of Agent objects to be used in the swarm.
• swarm_type (SwarmType): Type of swarm to be used.
• swarm (Union[AgentRearrange, MixtureOfAgents, SpreadSheetSwarm, SequentialWorkflow, ConcurrentWorkflow]): Instantiated swarm object.
• logs (List[SwarmLog]): List of log entries captured during operations.

Métodos:

• __init__(self, name: str, description: str, max_loops: int, agents: List[Agent], swarm_type: SwarmType, *args, **kwargs) : Initialize the SwarmRouter.
• _create_swarm(self, *args, **kwargs) : Create and return the specified swarm type.
• _log(self, level: str, message: str, task: str, metadata: Dict[str, Any]) : Create a log entry and add it to the logs list.
• run(self, task: str, *args, **kwargs) : Run the specified task on the selected swarm.
• get_logs(self) : Retrieve all logged entries.

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

Cambiar los tipos de enjambres

Puede crear múltiples instancias de Swarmrouter con diferentes tipos de enjambres:

 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
)

Agente

Caso de uso: Optimización del orden del agente para tareas complejas de múltiples pasos.

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

Mezcla

Caso de uso: combinando diversos agentes expertos para un análisis integral.

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

---

Sesión de incorporación

¡Ingrese ahora con el creador y el mantenedor principal de los enjambres, Kye Gómez, quien le mostrará cómo comenzar con la instalación, los ejemplos de uso y comenzar a construir su caso de uso personalizado! HAGA CLIC AQUÍ

---

Documentación

La documentación se encuentra aquí en: docs.swarms.world

---

Estructura de carpetas

The swarms package has been meticlously crafted for extreme use-ability and understanding, the swarms package is split up into various modules such as swarms.agents that holds pre-built agents, swarms.structs that holds a vast array of structures like Agent and multi Estructuras de agente. The 3 most important are structs , models , and agents .

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

---

? Contribuciones:

The easiest way to contribute is to pick any issue with the good first issue tag ?. Lea las pautas que contribuyen aquí. Informe de errores? Archivo aquí | Solicitud de función? Archivo aquí

Swarms es un proyecto de código abierto, y las contribuciones son muy bienvenidas. Si desea contribuir, puede crear nuevas funciones, corregir errores o mejorar la infraestructura. ¡Consulte el MD y nuestra junta contribuyente para participar en discusiones de hoja de ruta!

---

Acelerar

Acelerar errores, características y demostraciones para implementarnos apoyándonos aquí:

Comunidad

¿Unirse a nuestra creciente comunidad en todo el mundo, para obtener apoyo, ideas y discusiones en tiempo real sobre enjambres?

• Ver nuestro blog oficial
• Chatear en vivo con nosotros en Discord
• Síguenos en Twitter
• Conéctese con nosotros en LinkedIn
• Visítanos en YouTube
• ¡Únete a la comunidad de Swarms en Discord!
• Únase a nuestra reunión comunitaria de Swarms todos los jueves a la 1 p.m., hora de NYC, para desbloquear el potencial de los agentes autónomos para automatizar sus tareas diarias, se registre aquí

Licencia

Licencia pública general de GNU Affero General