[DOCS][AutoSwarmBuilder in Readme]

pull/1018/head
Kye Gomez 4 weeks ago
parent 7312393a71
commit b3e3f68ee8

@ -211,6 +211,48 @@ print(final_post)
-----
### 🤖 AutoSwarmBuilder: Autonomous Agent Generation
The `AutoSwarmBuilder` automatically generates specialized agents and their workflows based on your task description. Simply describe what you need, and it will create a complete multi-agent system with detailed prompts and optimal agent configurations. [Learn more about AutoSwarmBuilder](https://docs.swarms.world/en/latest/swarms/structs/auto_swarm_builder/)
```python
from swarms.structs.auto_swarm_builder import AutoSwarmBuilder
import json
# Initialize the AutoSwarmBuilder
swarm = AutoSwarmBuilder(
name="My Swarm",
description="A swarm of agents",
verbose=True,
max_loops=1,
return_agents=True,
model_name="gpt-4o-mini",
)
# Let the builder automatically create agents and workflows
result = swarm.run(
task="Create an accounting team to analyze crypto transactions, "
"there must be 5 agents in the team with extremely extensive prompts. "
"Make the prompts extremely detailed and specific and long and comprehensive. "
"Make sure to include all the details of the task in the prompts."
)
# The result contains the generated agents and their configurations
print(json.dumps(result, indent=4))
```
The `AutoSwarmBuilder` provides:
- **Automatic Agent Generation**: Creates specialized agents based on task requirements
- **Intelligent Prompt Engineering**: Generates comprehensive, detailed prompts for each agent
- **Optimal Workflow Design**: Determines the best agent interactions and workflow structure
- **Production-Ready Configurations**: Returns fully configured agents ready for deployment
- **Flexible Architecture**: Supports various swarm types and agent specializations
This feature is perfect for rapid prototyping, complex task decomposition, and creating specialized agent teams without manual configuration.
-----
## 🏗️ Multi-Agent Architectures For Production Deployments
`swarms` provides a variety of powerful, pre-built multi-agent architectures enabling you to orchestrate agents in various ways. Choose the right structure for your specific problem to build efficient and reliable production systems.

@ -6,11 +6,8 @@ swarm = AutoSwarmBuilder(
description="A swarm of agents",
verbose=True,
max_loops=1,
# random_models=False,
# return_agents=True,
model_name="gpt-4o-mini",
# generate_router_config=True,
return_agents=True,
model_name="gpt-4.1",
)
print(

@ -41,7 +41,7 @@ agent = Agent(
no_reasoning_prompt=True,
streaming_on=True,
# dashboard=True
llm_base_url="https://api.openai.com/v1"
llm_base_url="https://api.openai.com/v1",
)
out = agent.run(

@ -0,0 +1,111 @@
from swarms import Agent, ConcurrentWorkflow
from swarms_tools import coin_gecko_coin_api
# Create specialized agents for Solana, Bitcoin, Ethereum, Cardano, and Polkadot analysis using CoinGecko API
market_analyst_solana = Agent(
agent_name="Market-Trend-Analyst-Solana",
system_prompt="""You are a market trend analyst specializing in Solana (SOL).
Analyze SOL price movements, volume patterns, and market sentiment using real-time data from the CoinGecko API.
Focus on:
- Technical indicators and chart patterns for Solana
- Volume analysis and market depth for SOL
- Short-term and medium-term trend identification
- Support and resistance levels
Always use the CoinGecko API tool to fetch up-to-date Solana market data for your analysis.
Provide actionable insights based on this data.""",
model_name="claude-sonnet-4-20250514",
max_loops=1,
temperature=0.2,
tools=[coin_gecko_coin_api],
)
market_analyst_bitcoin = Agent(
agent_name="Market-Trend-Analyst-Bitcoin",
system_prompt="""You are a market trend analyst specializing in Bitcoin (BTC).
Analyze BTC price movements, volume patterns, and market sentiment using real-time data from the CoinGecko API.
Focus on:
- Technical indicators and chart patterns for Bitcoin
- Volume analysis and market depth for BTC
- Short-term and medium-term trend identification
- Support and resistance levels
Always use the CoinGecko API tool to fetch up-to-date Bitcoin market data for your analysis.
Provide actionable insights based on this data.""",
model_name="claude-sonnet-4-20250514",
max_loops=1,
temperature=0.2,
tools=[coin_gecko_coin_api],
)
market_analyst_ethereum = Agent(
agent_name="Market-Trend-Analyst-Ethereum",
system_prompt="""You are a market trend analyst specializing in Ethereum (ETH).
Analyze ETH price movements, volume patterns, and market sentiment using real-time data from the CoinGecko API.
Focus on:
- Technical indicators and chart patterns for Ethereum
- Volume analysis and market depth for ETH
- Short-term and medium-term trend identification
- Support and resistance levels
Always use the CoinGecko API tool to fetch up-to-date Ethereum market data for your analysis.
Provide actionable insights based on this data.""",
model_name="claude-sonnet-4-20250514",
max_loops=1,
temperature=0.2,
tools=[coin_gecko_coin_api],
)
market_analyst_cardano = Agent(
agent_name="Market-Trend-Analyst-Cardano",
system_prompt="""You are a market trend analyst specializing in Cardano (ADA).
Analyze ADA price movements, volume patterns, and market sentiment using real-time data from the CoinGecko API.
Focus on:
- Technical indicators and chart patterns for Cardano
- Volume analysis and market depth for ADA
- Short-term and medium-term trend identification
- Support and resistance levels
Always use the CoinGecko API tool to fetch up-to-date Cardano market data for your analysis.
Provide actionable insights based on this data.""",
model_name="claude-sonnet-4-20250514",
max_loops=1,
temperature=0.2,
tools=[coin_gecko_coin_api],
)
market_analyst_polkadot = Agent(
agent_name="Market-Trend-Analyst-Polkadot",
system_prompt="""You are a market trend analyst specializing in Polkadot (DOT).
Analyze DOT price movements, volume patterns, and market sentiment using real-time data from the CoinGecko API.
Focus on:
- Technical indicators and chart patterns for Polkadot
- Volume analysis and market depth for DOT
- Short-term and medium-term trend identification
- Support and resistance levels
Always use the CoinGecko API tool to fetch up-to-date Polkadot market data for your analysis.
Provide actionable insights based on this data.""",
model_name="claude-sonnet-4-20250514",
max_loops=1,
temperature=0.2,
tools=[coin_gecko_coin_api],
)
# Create concurrent workflow
crypto_analysis_swarm = ConcurrentWorkflow(
agents=[
market_analyst_solana,
market_analyst_bitcoin,
market_analyst_ethereum,
market_analyst_cardano,
market_analyst_polkadot,
],
max_loops=1,
)
crypto_analysis_swarm.run(
"Analyze your own specified coin and create a comprehensive analysis of the coin"
)

@ -0,0 +1,267 @@
import time
from typing import Dict, List
from swarms import Agent
from swarms.utils.litellm_tokenizer import count_tokens
class LongFormGenerator:
"""
A class for generating long-form content using the swarms Agent framework.
This class provides methods for creating comprehensive, detailed content
with support for continuation and sectioned generation.
"""
def __init__(self, model: str = "claude-sonnet-4-20250514"):
"""
Initialize the LongFormGenerator with specified model.
Args:
model (str): The model to use for content generation
"""
self.model = model
def estimate_tokens(self, text: str) -> int:
"""
Estimate token count for text.
Args:
text (str): The text to estimate tokens for
Returns:
int: Estimated token count
"""
return count_tokens(text=text, model=self.model)
def create_expansion_prompt(
self, topic: str, requirements: Dict
) -> str:
"""
Create optimized prompt for long-form content.
Args:
topic (str): The main topic to generate content about
requirements (Dict): Requirements for content generation
Returns:
str: Formatted prompt for content generation
"""
structure_requirements = []
if "sections" in requirements:
for i, section in enumerate(requirements["sections"]):
structure_requirements.append(
f"{i+1}. {section['title']} - {section.get('description', 'Provide comprehensive analysis')}"
)
length_guidance = (
f"Target length: {requirements.get('min_words', 2000)}-{requirements.get('max_words', 4000)} words"
if "min_words" in requirements
else ""
)
prompt = f"""Create a comprehensive, detailed analysis of: {topic}
REQUIREMENTS:
- This is a professional-level document requiring thorough treatment
- Each section must be substantive with detailed explanations
- Include specific examples, case studies, and technical details where relevant
- Provide multiple perspectives and comprehensive coverage
- {length_guidance}
STRUCTURE:
{chr(10).join(structure_requirements)}
QUALITY STANDARDS:
- Demonstrate deep expertise and understanding
- Include relevant technical specifications and details
- Provide actionable insights and practical applications
- Use professional language appropriate for expert audience
- Ensure logical flow and comprehensive coverage of all aspects
Begin your comprehensive analysis:"""
return prompt
def generate_with_continuation(
self, topic: str, requirements: Dict, max_attempts: int = 3
) -> str:
"""
Generate long-form content with continuation if needed.
Args:
topic (str): The main topic to generate content about
requirements (Dict): Requirements for content generation
max_attempts (int): Maximum number of continuation attempts
Returns:
str: Generated long-form content
"""
initial_prompt = self.create_expansion_prompt(
topic, requirements
)
# Create agent for initial generation
agent = Agent(
name="LongForm Content Generator",
system_prompt=initial_prompt,
model=self.model,
max_loops=1,
temperature=0.7,
max_tokens=4000,
)
# Generate initial response
content = agent.run(topic)
target_words = requirements.get("min_words", 2000)
# Check if continuation is needed
word_count = len(content.split())
continuation_count = 0
while (
word_count < target_words
and continuation_count < max_attempts
):
continuation_prompt = f"""Continue and expand the previous analysis. The current response is {word_count} words, but we need approximately {target_words} words total for comprehensive coverage.
Please continue with additional detailed analysis, examples, and insights. Focus on areas that could benefit from deeper exploration or additional perspectives. Maintain the same professional tone and analytical depth.
Continue the analysis:"""
# Create continuation agent
continuation_agent = Agent(
name="Content Continuation Agent",
system_prompt=continuation_prompt,
model=self.model,
max_loops=1,
temperature=0.7,
max_tokens=4000,
)
# Generate continuation
continuation_content = continuation_agent.run(
f"Continue the analysis on: {topic}"
)
content += "\n\n" + continuation_content
word_count = len(content.split())
continuation_count += 1
# Rate limiting
time.sleep(1)
return content
def generate_sectioned_content(
self,
topic: str,
sections: List[Dict],
combine_sections: bool = True,
) -> Dict:
"""
Generate content section by section for maximum length.
Args:
topic (str): The main topic to generate content about
sections (List[Dict]): List of section definitions
combine_sections (bool): Whether to combine all sections into one document
Returns:
Dict: Dictionary containing individual sections and optionally combined content
"""
results = {}
combined_content = ""
for section in sections:
section_prompt = f"""Write a comprehensive, detailed section on: {section['title']}
Context: This is part of a larger analysis on {topic}
Requirements for this section:
- Provide {section.get('target_words', 500)}-{section.get('max_words', 800)} words of detailed content
- {section.get('description', 'Provide thorough analysis with examples and insights')}
- Include specific examples, technical details, and practical applications
- Use professional language suitable for expert audience
- Ensure comprehensive coverage of all relevant aspects
Write the complete section:"""
# Create agent for this section
section_agent = Agent(
name=f"Section Generator - {section['title']}",
system_prompt=section_prompt,
model=self.model,
max_loops=1,
temperature=0.7,
max_tokens=3000,
)
# Generate section content
section_content = section_agent.run(
f"Generate section: {section['title']} for topic: {topic}"
)
results[section["title"]] = section_content
if combine_sections:
combined_content += (
f"\n\n## {section['title']}\n\n{section_content}"
)
# Rate limiting between sections
time.sleep(1)
if combine_sections:
results["combined"] = combined_content.strip()
return results
# Example usage
if __name__ == "__main__":
# Initialize the generator
generator = LongFormGenerator()
# Example topic and requirements
topic = "Artificial Intelligence in Healthcare"
requirements = {
"min_words": 2500,
"max_words": 4000,
"sections": [
{
"title": "Current Applications",
"description": "Analyze current AI applications in healthcare",
"target_words": 600,
"max_words": 800,
},
{
"title": "Future Prospects",
"description": "Discuss future developments and potential",
"target_words": 500,
"max_words": 700,
},
],
}
# Generate comprehensive content
content = generator.generate_with_continuation(
topic, requirements
)
print("Generated Content:")
print(content)
print(f"\nWord count: {len(content.split())}")
# Generate sectioned content
sections = [
{
"title": "AI in Medical Imaging",
"description": "Comprehensive analysis of AI applications in medical imaging",
"target_words": 500,
"max_words": 700,
},
{
"title": "AI in Drug Discovery",
"description": "Detailed examination of AI in pharmaceutical research",
"target_words": 600,
"max_words": 800,
},
]
sectioned_results = generator.generate_sectioned_content(
topic, sections
)
print("\nSectioned Content:")
for section_title, section_content in sectioned_results.items():
if section_title != "combined":
print(f"\n--- {section_title} ---")
print(section_content[:200] + "...")

@ -0,0 +1,29 @@
from swarms import Agent
def generate_comprehensive_content(topic, sections):
prompt = f"""You are tasked with creating a comprehensive, detailed analysis of {topic}.
This should be a thorough, professional-level document suitable for expert review.
Structure your response with the following sections, ensuring each is substantive and detailed:
{chr(10).join([f"{i+1}. {section} - Provide extensive detail with examples and analysis" for i, section in enumerate(sections)])}
For each section:
- Include multiple subsections where appropriate
- Provide specific examples and case studies
- Offer detailed explanations of complex concepts
- Include relevant technical details and specifications
- Discuss implications and considerations thoroughly
Aim for comprehensive coverage that demonstrates deep expertise. This is a professional document that should be thorough and substantive throughout."""
agent = Agent(
name="Comprehensive Content Generator",
system_prompt=prompt,
model="claude-sonnet-4-20250514",
max_loops=1,
temperature=0.5,
max_tokens=4000,
)
return agent.run(topic)

@ -257,6 +257,7 @@ class AutoSwarmBuilder:
model_name: str = "gpt-4.1",
generate_router_config: bool = False,
interactive: bool = False,
max_tokens: int = 8000,
):
"""Initialize the AutoSwarmBuilder.
@ -276,6 +277,7 @@ class AutoSwarmBuilder:
self.model_name = model_name
self.generate_router_config = generate_router_config
self.interactive = interactive
self.max_tokens = max_tokens
self.conversation = Conversation()
self.reliability_check()
@ -412,7 +414,7 @@ class AutoSwarmBuilder:
temperature=0.5,
base_model=config,
model_name=self.model_name,
max_tokens=8000,
max_tokens=self.max_tokens,
)
def create_agents(self, task: str):

Loading…
Cancel
Save