Skip to main content

​
Overview

MultiAgentHub is an abstract base class for managing multiple agents in Qwen-Agent. It provides a unified interface for accessing and managing a collection of agents with validation to ensure proper configuration.

​
Class Signature

from qwen_agent import MultiAgentHub

class MultiAgentHub(ABC):
    pass

​
Properties

​
agents

@property
def agents(self) -> List[Agent]
Returns the list of agents managed by this hub.
​
return
List[Agent]
List of Agent instances
Validation Rules:
  • Must have an _agents attribute of type List[Agent]
  • The list must be non-empty (at least one agent)
  • All agents must have non-empty string names
  • Agent names must be unique within the hub
Raises:
  • AttributeError or AssertionError if validation fails

​
agent_names

@property
def agent_names(self) -> List[str]
Returns the names of all agents.
​
return
List[str]
List of agent names

​
nonuser_agents

@property
def nonuser_agents(self) -> List[Agent]
Returns all agents except UserAgent instances.
​
return
List[Agent]
List of non-user agents

​
Implementation Requirements

Classes that inherit from MultiAgentHub must:
  1. Define an _agents attribute containing a list of Agent instances
  2. Ensure all agents have unique, non-empty names
  3. Maintain at least one agent in the list

​
Usage Example

​
Basic Implementation

from qwen_agent import Agent, MultiAgentHub
from qwen_agent.agents import Assistant
from typing import List

class MyMultiAgentSystem(MultiAgentHub):
    def __init__(self, llm_config: dict):
        # Initialize agents
        self._agents = [
            Assistant(
                name='researcher',
                description='Researches topics and provides detailed information',
                llm=llm_config
            ),
            Assistant(
                name='writer',
                description='Writes content based on research',
                llm=llm_config
            ),
            Assistant(
                name='editor',
                description='Reviews and edits content',
                llm=llm_config
            )
        ]

# Use the system
llm_config = {'model': 'qwen-max', 'api_key': 'your-api-key'}
system = MyMultiAgentSystem(llm_config)

print(f"Agents: {system.agent_names}")
# Output: Agents: ['researcher', 'writer', 'editor']

​
With Router

from qwen_agent.agents import Router, Assistant

# Create specialized agents
agents = [
    Assistant(
        name='math_expert',
        description='Solves mathematical problems',
        llm={'model': 'qwen-max'},
        function_list=['code_interpreter']
    ),
    Assistant(
        name='search_expert',
        description='Searches for information on the web',
        llm={'model': 'qwen-max'},
        function_list=['web_extractor']
    )
]

# Router is a MultiAgentHub
router = Router(
    llm={'model': 'qwen-max'},
    agents=agents,
    name='main_router'
)

print(f"Available agents: {router.agent_names}")
# Output: Available agents: ['math_expert', 'search_expert']

​
With GroupChat

from qwen_agent.agents import GroupChat, Assistant

# Create agents for group chat
agents = [
    Assistant(
        name='alice',
        description='A creative writer',
        system_message='You are Alice, a creative writer who loves storytelling.',
        llm={'model': 'qwen-max'}
    ),
    Assistant(
        name='bob',
        description='A technical expert',
        system_message='You are Bob, a technical expert who loves coding.',
        llm={'model': 'qwen-max'}
    )
]

# GroupChat is a MultiAgentHub
group_chat = GroupChat(
    agents=agents,
    agent_selection_method='auto',
    llm={'model': 'qwen-max'}
)

print(f"Chat participants: {group_chat.agent_names}")
# Output: Chat participants: ['alice', 'bob']

​
Validation Example

from qwen_agent import MultiAgentHub
from qwen_agent.agents import Assistant

class InvalidHub(MultiAgentHub):
    def __init__(self):
        # Invalid: agents without names
        self._agents = [
            Assistant(llm={'model': 'qwen-max'}),  # No name!
            Assistant(llm={'model': 'qwen-max'})   # No name!
        ]

try:
    hub = InvalidHub()
    agents = hub.agents  # This will raise an error
except AssertionError as e:
    print(f"Error: All agents must have a name.")

# Correct version
class ValidHub(MultiAgentHub):
    def __init__(self):
        self._agents = [
            Assistant(name='agent1', llm={'model': 'qwen-max'}),
            Assistant(name='agent2', llm={'model': 'qwen-max'})
        ]

hub = ValidHub()
print(hub.agent_names)  # ['agent1', 'agent2']

​
Common Patterns

​
Dynamic Agent Creation

class DynamicHub(MultiAgentHub):
    def __init__(self, agent_configs: List[dict], llm_config: dict):
        self._agents = [
            Assistant(
                name=cfg['name'],
                description=cfg['description'],
                system_message=cfg.get('system_message'),
                function_list=cfg.get('tools', []),
                llm=llm_config
            )
            for cfg in agent_configs
        ]

# Use it
configs = [
    {'name': 'coder', 'description': 'Writes code', 'tools': ['code_interpreter']},
    {'name': 'researcher', 'description': 'Researches topics', 'tools': ['web_extractor']}
]

hub = DynamicHub(configs, {'model': 'qwen-max'})

​
Agent Access by Name

class NamedHub(MultiAgentHub):
    def get_agent(self, name: str) -> Agent:
        for agent in self.agents:
            if agent.name == name:
                return agent
        raise ValueError(f"Agent '{name}' not found")
    
    def __init__(self, agents: List[Agent]):
        self._agents = agents

hub = NamedHub(agents)
coder = hub.get_agent('coder')

​
See Also

  • Router - Routes queries to specialized agents
  • GroupChat - Multi-agent conversation system
  • Agent - Base agent class

Build docs developers (and LLMs) love

Get started for freeTalk to us