swarms

A estrutura de orquestração multi-agente pronta para a produção de grau de qualidade

? Twitter • ? Discord • Plataforma enxame • ? Documentação

Características

Categoria	Características	Benefícios
? Arquitetura corporativa	• Infraestrutura pronta para produção • Sistemas de alta confiabilidade • Design modular • Madeira abrangente	• Tempo de inatividade reduzido • Manutenção mais fácil • Melhor depuração • Monitoramento aprimorado
? Orquestração do agente	• Enxames hierárquicos • Processamento paralelo • fluxos de trabalho seqüenciais • Fluxos de trabalho baseados em gráficos • Rearranjo do agente dinâmico	• Manipulação de tarefas complexas • desempenho aprimorado • fluxos de trabalho flexíveis • Execução otimizada
Recursos de integração	• Suporte de vários modelos • Criação de agente personalizado • Biblioteca de ferramentas extensa • Vários sistemas de memória	• Flexibilidade do provedor • Soluções personalizadas • Funcionalidade estendida • Gerenciamento de memória aprimorado
? Escalabilidade	• Processamento simultâneo • Gerenciamento de recursos • Balanceamento de carga • Escala horizontal	• Taxa de transferência mais alta • Uso de recursos eficientes • Melhor desempenho • Escala fácil
Ferramentas de desenvolvedor	• API simples • Documentação extensa • Comunidade ativa • Ferramentas da CLI	• Desenvolvimento mais rápido • Curva fácil de aprendizado • Apoio à comunidade • Implantação rápida
? Recursos de segurança	• Manuseio de erros • Limitação da taxa • Monitorando a integração • Loging de auditoria	• confiabilidade melhorada • Proteção da API • Melhor monitoramento • Rastreamento aprimorado
Recursos avançados	• Spreadsheetswarm • Chat em grupo • Registro de agentes • Mistura de agentes	• Gerenciamento de agentes de massa • AI colaborativa • Controle centralizado • Soluções complexas
? Suporte ao provedor	• Openai • Antrópico • Chromadb • Fornecedores personalizados	• Flexibilidade do provedor • Opções de armazenamento • Integração personalizada • Independência do fornecedor
? Recursos de produção	• Betades automáticas • Suporte assíncrono • Gerenciamento de meio ambiente • Tipo de segurança	• Melhor confiabilidade • desempenho aprimorado • Configuração fácil • Código mais seguro
Use suporte de caso	• Agentes específicos de tarefas • fluxos de trabalho personalizados • Soluções da indústria • estrutura extensível	• Implantação rápida • Soluções flexíveis • prontidão da indústria • Fácil personalização

---

Requisitos

• python3.10 ou acima!
• $ pip install -U swarms e, não se esqueça de instalar enxames!
• .env arquivo com chaves de API de seus fornecedores como OPENAI_API_KEY , ANTHROPIC_API_KEY
• Defina uma variável .env com o espaço de trabalho desejado DIR: WORKSPACE_DIR="agent_workspace" export WORKSPACE_DIR="agent_workspace"
• Finalmente, swarms onboarding para você começar.

Guias e passo a passo

Consulte nossa documentação para obter detalhes da implementação da grau de produção.

Seção	Links
Instalação	Instalação
Investir rápido	Comece
Mecanismos internos do agente	Arquitetura do agente
API do agente	API do agente
Integração de agentes externos Griptape, Autogen, etc	Integração de APIs externas
Criando agentes da YAML	Criando agentes da YAML
Por que você precisa de enxames	Por que a colaboração multiagente é necessária
Análise de Arquiteturas Swarm	Arquiteturas de enxames
Escolhendo o enxame certo para o seu problema de negócios sent	CLIQUE AQUI
AgenteRearRange Docs	CLIQUE AQUI

Instalar

$ pip3 install -U swarms

Integração

Agora que você baixou enxames com pip3 install -U swarms , temos acesso à CLI . Fique a bordo com CLI agora com:

swarms onboarding

Você também pode executar este comando para obter ajuda:

swarms help

Para mais documentação sobre a CLI, clique aqui

---

Exemplos de uso?

Aqui estão alguns scripts de exemplo para você começar. Para uma documentação mais abrangente, visite nossos documentos.

Nome de exemplo	Descrição	Tipo de exemplos	Link
Exemplos de enxames	Uma coleção de exemplos simples para demonstrar recursos de enxames.	Uso básico	https://github.com/the-swarm-corporation/swarms-examples?tab=readme-ov-file
Livro de receitas	Um guia abrangente com receitas para vários casos de uso e cenários.	Uso avançado	https://github.com/the-swarm-corporation/cookbook

---

Classe Agent

A classe Agent é um componente fundamental da estrutura de enxames, projetada para executar tarefas autonomamente. Ele funde LLMS, ferramentas e recursos de memória de longo prazo para criar um agente de pilha completa. A classe Agent é altamente personalizável, permitindo o controle de granulação fina sobre seu comportamento e interações.

Método run

O método run é o ponto de entrada principal para executar tarefas com uma instância Agent . Ele aceita uma sequência de tarefas como a principal tarefa de entrada e a processa de acordo com a configuração do agente. E também pode aceitar um parâmetro img como img="image_filepath.png para processar imagens se você tiver um VLM

Configurações e personalização

A classe Agent oferece uma variedade de configurações para adaptar seu comportamento a necessidades específicas. Algumas configurações importantes incluem:

Contexto	Descrição	Valor padrão
agent_name	O nome do agente.	"DefaultAgent"
system_prompt	O prompt do sistema para usar para o agente.	"Prompt de sistema padrão."
llm	O modelo de idioma a ser usado para processamento de tarefas.	Instância OpenAIChat
max_loops	O número máximo de loops a serem executados para uma tarefa.	1
autosave	Ativa ou desativa a economia automática do estado do agente.	Falso
dashboard	Ativa ou desativa o painel para o agente.	Falso
verbose	Controla a verbosidade da saída do agente.	Falso
dynamic_temperature_enabled	Ativa ou desativa o ajuste dinâmico de temperatura para o modelo de idioma.	Falso
saved_state_path	O caminho para salvar o estado do agente.	"Agent_state.json"
user_name	O nome de usuário associado ao agente.	"Default_user"
retry_attempts	O número de tentativas de nova tentativa de tarefas com falha.	1
context_length	O comprimento máximo do contexto a considerar para tarefas.	200000
return_step_meta	Controla se deve retornar metadados da etapa na saída.	Falso
output_type	O tipo de saída para retornar (por exemplo, "json", "string").	"corda"

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

---

Integração de pano com enxames para melhorar a memória de longo prazo

Agent equipado com memória quase-infinita de longo prazo usando RAG (Relational Agent Gráfico) para obter recursos avançados de entendimento, análise e recuperação.

Diagrama de sereia para integração de trapos

 Gráfico TD
    A [Inicialize Agente com RAG] -> B [Tarefa de recebimento]
    B-> C [MEMÓRIA DE LONGO PRONTAGEM DE CONSULTAÇÃO]
    C -> D [Tarefa de processo com contexto]
    D -> E [Gere resposta]
    E-> f [Atualizar memória de longo prazo]
    F -> g [saída de retorno]

Etapa 1: Inicialize o 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
)

Etapa 2: Defina o 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" ))

Etapa 3: Inicialize o agente com pano

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

---

Configurações do agente MISC

Fornecemos uma vasta gama de recursos para salvar estados de agentes usando JSON, YAML, TOML, Carregar PDFs, trabalhos em lote e muito mais!

Tabela de métodos

Método	Descrição
to_dict()	Converte o objeto do agente em um dicionário.
to_toml()	Converte o objeto do agente em uma corda Toml.
model_dump_json()	Despeja o modelo em um arquivo json.
model_dump_yaml()	Despeja o modelo em um arquivo YAML.
ingest_docs()	Ingerir documentos na base de conhecimento do agente.
receive_message()	Recebe uma mensagem de um usuário e o processa.
send_agent_message()	Envia uma mensagem do agente para um usuário.
filtered_run()	Executa o agente com um prompt de sistema filtrado.
bulk_run()	Executa o agente com vários prompts do sistema.
add_memory()	Adiciona uma memória ao agente.
check_available_tokens()	Verifica o número de tokens disponíveis para o agente.
tokens_checks()	Executa verificações de token para o agente.
print_dashboard()	Imprime o painel do agente.
get_docs_from_doc_folders()	Busca todos os documentos das pastas do documento.
activate_agentops()	Ativa as operações do agente.
check_end_session_agentops()	Verifica o final da sessão para operações do agente.

 # # 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 com basemodel pydantic como tipo de saída

A seguir, é apresentado um exemplo de um agente que entra um modelo de base pydantic e o produz ao mesmo tempo:

 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 multi -modal

Execute o agente com várias modalidades úteis para várias tarefas do mundo real em fabricação, logística e saúde.

 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

O ToolAgent é um agente que pode usar ferramentas através da chamada de função JSON. Ele ingere qualquer modelo de código aberto do Huggingface e é extremamente modular e conectado e reproduz. Precisamos de ajuda para adicionar suporte geral a todos os modelos em breve.

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

Integração de agentes externos

A integração de agentes externos de outras estruturas de agentes é fácil com enxames.

Passos:

1. Crie uma nova classe que herde Agent
2. Crie um método .run(task: str) -> str que executa o agente e retorna a resposta.
3. O novo agente deve retornar uma sequência da resposta. Mas você pode adicionar métodos adicionais para salvar a saída ao JSON.

Exemplo Giptrape

Por exemplo, aqui está um exemplo de como criar um agente da Griptape.

Veja como você pode criar um agente Griptape personalizado que se integra à estrutura Swarms herdando a classe Agent em enxames e substituindo a run(task: str) -> str Método.

 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 -chave:

1. Griptapeswarmsagent : uma classe personalizada que herda da classe SwarmsAgent e integra o agente Griptape.
2. Run (Tarefa: STR) -> STR : Um método que pega uma sequência de tarefas, o processa (por exemplo, dividindo -se em um URL e nome do arquivo) e executa o agente Griptape com as entradas fornecidas.
3. Ferramentas Giptrape : as ferramentas integradas ao agente Griptape (por exemplo, WebScraperTool , PromptSummaryTool , FileManagerTool ) permitem raspagem na web, resumo e gerenciamento de arquivos.

Agora você pode facilmente conectar este agente Griptape personalizado à estrutura Swarms e usá -la para executar tarefas!

Entendendo enxames

O que é um enxame?

Um enxame refere -se a um grupo de mais de dois agentes trabalhando em colaboração para atingir uma meta comum. Esses agentes podem ser entidades de software, como LLMs que interagem entre si para executar tarefas complexas. O conceito de enxame é inspirado em sistemas naturais, como colônias de formigas ou bandos de aves, onde comportamentos individuais simples levam à dinâmica complexa de grupos e às capacidades de solução de problemas.

Como as arquiteturas enxames facilitam a comunicação

As arquiteturas de enxames são projetadas para estabelecer e gerenciar a comunicação entre agentes dentro de um enxame. Essas arquiteturas definem como os agentes interagem, compartilham informações e coordenam suas ações para alcançar os resultados desejados. Aqui estão alguns aspectos -chave das arquiteturas de enxames:

1. Comunicação hierárquica : em enxames hierárquicos, a comunicação flui de agentes de nível superior a agentes de nível inferior. Os agentes de nível superior atuam como coordenadores, distribuindo tarefas e agregando resultados. Essa estrutura é eficiente para tarefas que requerem controle de cima para baixo e tomada de decisão.

2. Comunicação paralela : em enxames paralelos, os agentes operam de forma independente e se comunicam, conforme necessário. Essa arquitetura é adequada para tarefas que podem ser processadas simultaneamente sem dependências, permitindo uma execução e escalabilidade mais rápidas.

3. Comunicação seqüencial : os enxames sequenciais processam tarefas em uma ordem linear, onde a saída de cada agente se torna a entrada para o próximo agente. Isso garante que as tarefas com dependências sejam tratadas na sequência correta, mantendo a integridade do fluxo de trabalho.

4. Comunicação de malha : Nos enxames de malha, os agentes estão totalmente conectados, permitindo que qualquer agente se comunique com qualquer outro agente. Essa configuração fornece alta flexibilidade e redundância, tornando -a ideal para sistemas complexos que requerem interações dinâmicas.

5. Comunicação Federada : Os enxames federados envolvem vários enxames independentes que colaboram compartilhando informações e resultados. Cada enxame opera autonomamente, mas pode contribuir para uma tarefa maior, permitindo a solução de problemas distribuída em diferentes nós.

As arquiteturas de enxames aproveitam esses padrões de comunicação para garantir que os agentes trabalhem juntos com eficiência, adaptando -se aos requisitos específicos da tarefa em questão. Ao definir protocolos e modelos de interação de comunicação claros, as arquiteturas enxames permitem a orquestração perfeita de vários agentes, levando a recursos aprimorados de desempenho e solução de problemas.

Nome	Descrição	Link de código	Casos de uso
Enxames hierárquicos	Um sistema em que os agentes são organizados em uma hierarquia, com agentes de nível superior coordenando agentes de nível inferior para alcançar tarefas complexas.	Link de código	Otimização do processo de fabricação, gerenciamento de vendas em vários níveis, coordenação de recursos de saúde
Reorganização do agente	Uma configuração em que os agentes se reorganizam dinamicamente com base nos requisitos de tarefas e nas condições ambientais.	Link de código	Linhas de fabricação adaptativa, realinhamento dinâmico de território de vendas, pessoal flexível de saúde
Fluxos de trabalho simultâneos	Os agentes executam tarefas diferentes simultaneamente, coordenando para concluir uma meta maior.	Link de código	Linhas de produção simultâneas, operações de vendas paralelas, processos simultâneos de atendimento ao paciente
Coordenação seqüencial	Os agentes executam tarefas em uma sequência específica, onde a conclusão de uma tarefa desencadeia o início do próximo.	Link de código	Linhas de montagem passo a passo, processos de vendas seqüenciais, fluxos de trabalho de tratamento do paciente gradual
Processamento paralelo	Os agentes trabalham em diferentes partes de uma tarefa simultaneamente para acelerar o processo geral.	Link de código	Processamento de dados paralelos na fabricação, análise de vendas simultâneas, exames médicos simultâneos
Mistura de agentes	Um enxame heterogêneo, onde agentes com diferentes recursos são combinados para resolver problemas complexos.	Link de código	Previsão financeira, solução complexa de solução exigindo diversas habilidades
Fluxo de trabalho gráfico	Os agentes colaboram em um formato de gráfico aciclico direcionado (DAG) para gerenciar dependências e tarefas paralelas.	Link de código	Pipelines de desenvolvimento de software orientados por IA, gerenciamento complexo de projetos
Bate -papo em grupo	Os agentes se envolvem em uma interação semelhante a um bate-papo para tomar decisões em colaboração.	Link de código	Tomada de decisão colaborativa em tempo real, negociações de contrato
Registro de agentes	Um registro centralizado onde os agentes são armazenados, recuperados e invocados dinamicamente.	Link de código	Gerenciamento de agentes dinâmicos, mecanismos de recomendação em evolução
Planilha Swarm	Gerencia as tarefas em escala, rastreando saídas do agente em um formato estruturado como os arquivos CSV.	Link de código	Análise de marketing em larga escala, auditorias financeiras
Enxame da floresta	Uma estrutura de enxame que organiza agentes em uma hierarquia semelhante a uma árvore para processos complexos de tomada de decisão.	Link de código	Fluxos de trabalho em vários estágios, aprendizado hierárquico de reforço
Roteador enxame	Rotas e escolhe a arquitetura enxame com base nos requisitos de tarefas e nos agentes disponíveis.	Link de código	Roteamento dinâmico de tarefas, seleção de arquitetura de enxame adaptável, alocação de agentes otimizados

SequentialWorkflow

O fluxo de trabalho seqüencial permite executar tarefas sequencialmente com Agent e depois passar a saída para o próximo agente e em diante até que você tenha especificado seus loops máximos.

 Gráfico LR
    A [Agente 1] -> B [Agente 2]
    B -> C [Agente 3]
    C -> D [Agente 4]
    D -> E [MAX LOOPS]
    E -> f [fim]

Métodos

Método	Descrição	Parâmetros	Valor de retorno
__init__	Inicialize o fluxo sequencial de trabalho	agents : Lista de objetos do agente max_loops : número máximo de iterações verbose : booleano para saída detalhada	Nenhum
run	Execute o fluxo de trabalho	input_data : entrada inicial para o primeiro agente	Saída final depois que todos os agentes tenham processado

Entradas

Entrada	Tipo	Descrição
agents	Lista [agente]	Lista de objetos do agente a serem executados sequencialmente
max_loops	int	Número máximo de vezes que toda a sequência será repetida
verbose	bool	Se for verdade, imprimir informações detalhadas durante a execução

Saída

O método run retorna a saída final depois que todos os agentes processam a entrada sequencialmente.

Neste exemplo, cada Agent representa uma tarefa que é executada sequencialmente. A saída de cada agente é passada para o próximo agente na sequência até que o número máximo de loops seja atingido. Esse fluxo de trabalho é particularmente útil para tarefas que exigem uma série de etapas a serem executadas em uma ordem específica, como pipelines de processamento de dados ou cálculos complexos que dependem da saída de etapas 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

A técnica de orquestração AgentRearrange , inspirada em Einops e Einsum, permite definir e mapear as relações entre vários agentes. Ele fornece uma ferramenta poderosa para orquestrar fluxos de trabalho complexos, permitindo que você especifique relacionamentos lineares e seqüenciais, como a -> a1 -> a2 -> a3 , ou relacionamentos simultâneos em que o primeiro agente envia uma mensagem para 3 agentes simultaneamente: a -> a1, a2, a3 . Esse nível de personalização permite a criação de fluxos de trabalho altamente eficientes e dinâmicos, onde os agentes podem trabalhar em paralelo ou em sequência, conforme necessário. A técnica AgentRearrange é uma adição valiosa à biblioteca Swarms, fornecendo um novo nível de flexibilidade e controle sobre a orquestração de agentes. Para obter informações e exemplos mais detalhados, consulte a documentação oficial.

Métodos

Método	Descrição	Parâmetros	Valor de retorno
__init__	Inicialize o agenteRearRange	agents : Lista de objetos do agente flow : String descrevendo o fluxo do agente	Nenhum
run	Execute o fluxo de trabalho	input_data : entrada inicial para o primeiro agente	Saída final depois que todos os agentes tenham processado

Entradas

Entrada	Tipo	Descrição
agents	Lista [agente]	Lista de objetos de agente a serem orquestrados
flow	str	String descrevendo o fluxo de agentes (por exemplo, "a -> b, c")

Saída

O método run retorna a saída final depois que todos os agentes processam a entrada de acordo com o fluxo especificado.

 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

Em breve...

GraphSwarm

O GraphSwarm é um sistema de gerenciamento de fluxo de trabalho projetado para orquestrar tarefas complexas, aproveitando o poder da teoria dos gráficos. Ele permite a criação de um gráfico acíclico direcionado (DAG) para modelar dependências entre tarefas e agentes. Isso permite uma atribuição, execução e monitoramento eficientes de tarefas.

Aqui está um detalhamento de como o GraphSwarm funciona:

1. Criação de nós : o fluxo de trabalho GraphSwarm é composto de nós, que podem ser agentes ou tarefas. Os agentes são responsáveis ​​pela execução de tarefas e as tarefas representam operações específicas que precisam ser executadas. No exemplo, dois agentes ( agent1 e agent2 ) e uma tarefa ( task1 ) são criados.
2. Definição da borda : as arestas são usadas para definir as relações entre nós. Nesse caso, as arestas são criadas para conectar agent1 e agent2 à task1 , indicando que ambos os agentes são capazes de executar task1 .
3. Pontos de entrada e final : o fluxo de trabalho GraphSwarm requer a definição de pontos de entrada (onde o fluxo de trabalho inicia) e os pontos finais (onde o fluxo de trabalho conclui). Neste exemplo, agent1 e agent2 são definidos como pontos de entrada e task1 é definido como o ponto final.
4. Visualização : o GraphSwarm fornece um recurso de visualização para representar graficamente o fluxo de trabalho. Isso permite fácil compreensão e depuração da estrutura do fluxo de trabalho.
5. Execução : O fluxo de trabalho GraphSwarm é executado atravessando o gráfico dos pontos de entrada para os pontos finais. Nesse caso, agent1 e agent2 executam task1 simultaneamente, e os resultados são coletados.
6. Resultados : Os resultados finais da execução do fluxo de trabalho são agregados e retornados. Neste exemplo, o resultado da execução task1 é "Tarefa concluída".

O GraphSwarm oferece vários benefícios, incluindo:

• Concorrência : permite a execução de tarefas simultaneamente, melhorando a eficiência geral do fluxo de trabalho.
• Flexibilidade : permite a atribuição dinâmica de tarefas com base na disponibilidade do agente e nos requisitos de tarefas.
• Escalabilidade : suporta a adição de novos agentes e tarefas conforme necessário, tornando-o adequado para fluxos de trabalho em larga escala.
• Visualização : fornece uma representação gráfica do fluxo de trabalho, facilitando a compreensão e a depuração.

Ao alavancar o GraphSwarm , os fluxos de trabalho complexos podem ser gerenciados com eficiência, e as tarefas podem ser executadas de maneira coordenada e escalável.

Métodos

Método	Descrição	Parâmetros	Valor de retorno
add_node	Adicione um nó ao gráfico	node : objeto de nó	Nenhum
add_edge	Adicione uma vantagem ao gráfico	edge : objeto de borda	Nenhum
set_entry_points	Defina os pontos de entrada do gráfico	entry_points : Lista de IDs de nó	Nenhum
set_end_points	Defina os pontos finais do gráfico	end_points : lista de IDs de nó	Nenhum
visualize	Gerar uma representação visual do gráfico	Nenhum	Representação da string do gráfico
run	Execute o fluxo de trabalho	Nenhum	Resultados do Dicionário de Execução

Entradas

Entrada	Tipo	Descrição
Node	Objeto	Representa um nó no gráfico (agente ou tarefa)
Edge	Objeto	Representa uma borda conectando dois nós
entry_points	Lista [STR]	Lista de IDs de nó onde o fluxo de trabalho começa
end_points	Lista [STR]	Lista de IDs de nó onde o fluxo de trabalho termina

Saída

O método run retorna um dicionário que contém os resultados da execução de todos os nós no gráfico.

 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 é uma implementação baseada no artigo: "A mistura de agentes aprimora os grandes recursos do modelo de linguagem" por Together.ai, disponível em https://arxiv.org/abs/2406.04692. Ele atinge os resultados de última geração (SOTA) no Alpacaeeval 2.0, mt-banco e frasco, superando o GPT-4 omni. Essa arquitetura é particularmente adequada para tarefas que requerem paralelização seguida de processamento seqüencial em outro loop.

Métodos

Método	Descrição	Parâmetros	Valor de retorno
__init__	Inicialize as mixturefagents	name : Nome do enxame agents : Lista de objetos do agente layers : Número de camadas de processamento final_agent : agente para processamento final	Nenhum
run	Execute o enxame	task : Tarefa de entrada para o enxame	Saída final depois que todos os agentes tenham processado

Entradas

Entrada	Tipo	Descrição
name	str	Nome do enxame
agents	Lista [agente]	Lista de objetos do agente a serem usados ​​no enxame
layers	int	Número de camadas de processamento no enxame
final_agent	Agente	Agente Responsável pelo processamento final

Saída

O método run retorna a saída final depois que todos os agentes processam a entrada de acordo com as camadas especificadas e o agente 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 )

Spreadsheetswarm

O SpreadSheetSwarm foi projetado para gerenciamento e supervisão simultânea de milhares de agentes, facilitando uma abordagem um para muitos para processamento de tarefas eficientes e análise de saída.

Principais recursos

• Concorrência : permite a execução simultânea de vários agentes, reduzindo significativamente o tempo de processamento e aumentando a eficiência geral do sistema.
• Um para muitos : permite que uma única tarefa seja distribuída dinamicamente entre vários agentes, garantindo que cada agente seja utilizado em todo o seu potencial.
• Escalabilidade : suporta a integração de milhares de agentes, tornando-a uma solução ideal para processamento de tarefas em larga escala e análise de dados.

Métodos

Método	Descrição	Parâmetros	Valor de retorno
__init__	Inicialize a spreadsheetswarm	name : Nome do enxame description : Descrição do enxame agents : Lista de objetos do agente autosave_on : booleano para ativar o AutoSave save_file_path : Path para salvar a planilha run_all_agents : booleano para administrar todos os agentes ou não max_loops : número máximo de loops	Nenhum
run	Execute o enxame	task : Tarefa de entrada para o enxame	Dicionário de saídas do agente

Entradas

Entrada	Tipo	Descrição
name	str	Nome do enxame
description	str	Descrição do propósito do enxame
agents	Lista [agente]	Lista de objetos do agente a serem usados ​​no enxame
autosave_on	bool	Habilitar a economia automática de resultados
save_file_path	str	Caminho para salvar os resultados da planilha
run_all_agents	bool	Se deve executar todos os agentes ou selecionar com base na relevância
max_loops	int	Número máximo de loops de processamento

Saída

O método run retorna um dicionário que contém as saídas de cada agente que processou a tarefa.

Saiba mais nos documentos aqui:

 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

A arquitetura ForestSwarm foi projetada para atribuição de tarefas eficientes, selecionando dinamicamente o agente mais adequado de uma coleção de árvores. Isso é conseguido através do processamento de tarefas assíncronas, onde os agentes são escolhidos com base em sua relevância para a tarefa em questão. A relevância é determinada calculando a semelhança entre os avisos do sistema associados a cada agente e as palavras -chave presentes na própria tarefa. Para uma compreensão mais aprofundada de como ForestSwarm funciona, consulte a documentação oficial.

Métodos

Método	Descrição	Parâmetros	Valor de retorno
__init__	Inicialize o floresta	trees : Lista de objetos de árvore	Nenhum
run	Execute o Florestwarm	task : Tarefa de entrada para o enxame	Saída do agente mais relevante

Entradas

Entrada	Tipo	Descrição
trees	Lista [árvore]	Lista de objetos de árvore, cada um contendo objetos treagentes
task	str	A tarefa a ser processada pelo Forestwarm

Saída

O método run retorna a saída do agente mais relevante selecionado com base na tarefa de entrada.

 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

A classe SwarmRouter é um sistema de roteamento flexível projetado para gerenciar diferentes tipos de enxames para execução de tarefas. Ele fornece uma interface unificada para interagir com vários tipos de enxames, incluindo AgentRearrange , MixtureOfAgents , SpreadSheetSwarm , SequentialWorkflow e ConcurrentWorkflow . Adicionaremos continuamente mais e mais arquiteturas de enxames aqui à medida que progredimos com novas arquiteturas.

Atributos:

• name (STR): Nome da instância do SwarmRouter.
• description (STR): Descrição da instância do SwarmRouter.
• max_loops (int): número máximo de loops para executar.
• agents (lista [agente]): Lista de objetos do agente a serem usados ​​no enxame.
• swarm_type (swarmType): tipo de enxame a ser usado.
• swarm (Union [AgentRearRange, MixtureOfagents, Spreadsheetswarm, sequencialworkflow, Concurrentworkflow]): Objeto de enxame instanciado.
• logs (List [SwarmLog]): Lista de entradas de log capturadas durante as operações.

Métodos:

• __init__(self, name: str, description: str, max_loops: int, agents: List[Agent], swarm_type: SwarmType, *args, **kwargs) : inicialize o swarmRouter.
• _create_swarm(self, *args, **kwargs) : Crie e retorne o tipo de enxame especificado.
• _log(self, level: str, message: str, task: str, metadata: Dict[str, Any]) : crie uma entrada de log e adicione -a à lista de logs.
• run(self, task: str, *args, **kwargs) : execute a tarefa especificada no enxame selecionado.
• get_logs(self) : recupere todas as entradas registradas.

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

Mudança de tipos de enxames

Você pode criar várias instâncias do SwarmRouter com diferentes tipos de enxame:

 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
)

AgenteRearRange

Caso de uso: otimizando a ordem do agente para tarefas complexas de várias etapas.

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

Mixtureofagents

Caso de uso: combinando diversos agentes especialistas para análises abrangentes.

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

---

Sessão de integração

Fique a bordo agora com o criador e o mantenedor de enxames, Kye Gomez, que mostrará como começar a instalação, exemplos de uso e começar a construir seu caso de uso personalizado! CLIQUE AQUI

---

Documentação

A documentação está localizada aqui em: docs.swarms.world

---

Estrutura de pastas

O pacote Swarms foi meticulosamente criado para extrema capacidade de uso e compreensão, o pacote swarms.structs é dividido em vários módulos Agent como swarms.agents estruturas de agentes. Os 3 mais importantes são structs , models e agents .

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

---

? Contribuições:

A maneira mais fácil de contribuir é escolher algum problema com a good first issue ? Leia as diretrizes contribuintes aqui. Relatório de bug? Arquivo aqui | Solicitação de recurso? Arquivo aqui

Swarms é um projeto de código aberto, e as contribuições são muito bem-vindas. Se você deseja contribuir, pode criar novos recursos, corrigir erros ou melhorar a infraestrutura. Consulte o contribuinte.md e nosso conselho contribuinte para participar de discussões no roteiro!

---

Acelere o atraso

Acelere bugs, recursos e demos a serem implementados, apoiando -nos aqui:

Comunidade

Junte-se à nossa crescente comunidade em todo o mundo, para apoio, idéias e discussões em tempo real sobre enxames?

• Veja nosso blog oficial
• Bate -papo ao vivo conosco na discórdia
• Siga -nos no Twitter
• Conecte -se conosco no LinkedIn
• Visite -nos no YouTube
• Junte -se à comunidade Swarms na discórdia!
• Junte -se à reunião da comunidade Swarms toda quinta

Licença

GNU Affero Geral Public License