swarms api best practices

docs/best_practices.md

@@ -0,0 +1,241 @@
+---
+title: Best Practices for Multi-Agent Systems
+description: A comprehensive guide to building and managing multi-agent systems
+---
+
+# Best Practices for Multi-Agent Systems
+
+## Overview
+
+This guide provides comprehensive best practices for designing, implementing, and managing multi-agent systems. It covers key aspects from architecture selection to performance optimization and security considerations.
+
+```mermaid
+graph TD
+    A[Multi-Agent System] --> B[Architecture]
+    A --> C[Implementation]
+    A --> D[Management]
+    A --> E[Security]
+    
+    B --> B1[HHCS]
+    B --> B2[Auto Agent Builder]
+    B --> B3[SwarmRouter]
+    
+    C --> C1[Agent Design]
+    C --> C2[Communication]
+    C --> C3[Error Handling]
+    
+    D --> D1[Monitoring]
+    D --> D2[Scaling]
+    D --> D3[Performance]
+    
+    E --> E1[Data Privacy]
+    E --> E2[Access Control]
+    E --> E3[Audit Logging]
+```
+
+## Why Multi-Agent Systems?
+
+Individual agents face several limitations that multi-agent systems can overcome:
+
+```mermaid
+graph LR
+    A[Individual Agent Limitations] --> B[Context Window Limits]
+    A --> C[Single Task Execution]
+    A --> D[Hallucination]
+    A --> E[No Collaboration]
+    
+    F[Multi-Agent Solutions] --> G[Distributed Processing]
+    F --> H[Parallel Task Execution]
+    F --> I[Cross-Verification]
+    F --> J[Collaborative Intelligence]
+```
+
+### Key Benefits
+
+1. **Enhanced Reliability**
+   - Cross-verification between agents
+   - Redundancy and fault tolerance
+   - Consensus-based decision making
+
+2. **Improved Efficiency**
+   - Parallel processing capabilities
+   - Specialized agent roles
+   - Resource optimization
+
+3. **Better Accuracy**
+   - Multiple verification layers
+   - Collaborative fact-checking
+   - Consensus-driven outputs
+
+## Architecture Selection
+
+Choose the appropriate architecture based on your needs:
+
+| Architecture | Best For | Key Features |
+|--------------|----------|--------------|
+| HHCS | Complex, multi-domain tasks | - Clear task routing<br>- Specialized handling<br>- Parallel processing |
+| Auto Agent Builder | Dynamic, evolving tasks | - Self-organizing<br>- Flexible scaling<br>- Adaptive creation |
+| SwarmRouter | Varied task types | - Multiple workflows<br>- Simple configuration<br>- Flexible deployment |
+
+## Implementation Best Practices
+
+### 1. Agent Design
+
+```mermaid
+graph TD
+    A[Agent Design] --> B[Clear Role Definition]
+    A --> C[Focused System Prompts]
+    A --> D[Error Handling]
+    A --> E[Memory Management]
+    
+    B --> B1[Specialized Tasks]
+    B --> B2[Defined Responsibilities]
+    
+    C --> C1[Task-Specific Instructions]
+    C --> C2[Communication Guidelines]
+    
+    D --> D1[Retry Mechanisms]
+    D --> D2[Fallback Strategies]
+    
+    E --> E1[Context Management]
+    E --> E2[History Tracking]
+```
+
+### 2. Communication Protocols
+
+- **State Alignment**
+  - Begin with shared understanding
+  - Regular status updates
+  - Clear task progression
+
+- **Information Sharing**
+  - Transparent decision making
+  - Explicit acknowledgments
+  - Structured data formats
+
+### 3. Error Handling
+
+```python
+try:
+    result = router.route_task(task)
+except Exception as e:
+    logger.error(f"Task routing failed: {str(e)}")
+    # Implement retry or fallback strategy
+```
+
+## Performance Optimization
+
+### 1. Resource Management
+
+```mermaid
+graph LR
+    A[Resource Management] --> B[Memory Usage]
+    A --> C[CPU Utilization]
+    A --> D[API Rate Limits]
+    
+    B --> B1[Caching]
+    B --> B2[Cleanup]
+    
+    C --> C1[Load Balancing]
+    C --> C2[Concurrent Processing]
+    
+    D --> D1[Rate Limiting]
+    D --> D2[Request Batching]
+```
+
+### 2. Scaling Strategies
+
+1. **Horizontal Scaling**
+   - Add more agents for parallel processing
+   - Distribute workload across instances
+   - Balance resource utilization
+
+2. **Vertical Scaling**
+   - Optimize individual agent performance
+   - Enhance memory management
+   - Improve processing efficiency
+
+## Security Considerations
+
+### 1. Data Privacy
+
+- Implement encryption for sensitive data
+- Secure communication channels
+- Regular security audits
+
+### 2. Access Control
+
+```mermaid
+graph TD
+    A[Access Control] --> B[Authentication]
+    A --> C[Authorization]
+    A --> D[Audit Logging]
+    
+    B --> B1[Identity Verification]
+    B --> B2[Token Management]
+    
+    C --> C1[Role-Based Access]
+    C --> C2[Permission Management]
+    
+    D --> D1[Activity Tracking]
+    D --> D2[Compliance Monitoring]
+```
+
+## Monitoring and Maintenance
+
+### 1. Key Metrics
+
+- Response times
+- Success rates
+- Error rates
+- Resource utilization
+- API usage
+
+### 2. Logging Best Practices
+
+```python
+# Structured logging example
+logger.info({
+    'event': 'task_completion',
+    'task_id': task.id,
+    'duration': duration,
+    'agents_involved': agent_count,
+    'status': 'success'
+})
+```
+
+### 3. Alert Configuration
+
+Set up alerts for:
+- Critical errors
+- Performance degradation
+- Resource constraints
+- Security incidents
+
+## Getting Started
+
+1. **Start Small**
+   - Begin with a pilot project
+   - Test with limited scope
+   - Gather metrics and feedback
+
+2. **Scale Gradually**
+   - Increase complexity incrementally
+   - Add agents as needed
+   - Monitor performance impact
+
+3. **Maintain Documentation**
+   - Keep system diagrams updated
+   - Document configuration changes
+   - Track performance optimizations
+
+## Conclusion
+
+Building effective multi-agent systems requires careful consideration of architecture, implementation, security, and maintenance practices. By following these guidelines, you can create robust, efficient, and secure multi-agent systems that effectively overcome the limitations of individual agents.
+
+!!! tip "Remember"
+    - Start with clear objectives
+    - Choose appropriate architecture
+    - Implement proper security measures
+    - Monitor and optimize performance
+    - Document everything 

docs/concepts/limitations.md

@@ -0,0 +1,160 @@
+# Limitations of Individual Agents
+
+This section explores the fundamental limitations of individual AI agents and why multi-agent systems are necessary for complex tasks. Understanding these limitations is crucial for designing effective multi-agent architectures.
+
+## Overview
+
+```mermaid
+graph TD
+    A[Individual Agent Limitations] --> B[Context Window Limits]
+    A --> C[Hallucination]
+    A --> D[Single Task Execution]
+    A --> E[Lack of Collaboration]
+    A --> F[Accuracy Issues]
+    A --> G[Processing Speed]
+```
+
+## 1. Context Window Limits
+
+### The Challenge
+Individual agents are constrained by fixed context windows, limiting their ability to process large amounts of information simultaneously.
+
+```mermaid
+graph LR
+    subgraph "Context Window Limitation"
+        Input[Large Document] --> Truncation[Truncation]
+        Truncation --> ProcessedPart[Processed Part]
+        Truncation --> UnprocessedPart[Unprocessed Part]
+    end
+```
+
+### Impact
+- Limited understanding of large documents
+- Fragmented processing of long conversations
+- Inability to maintain extended context
+- Loss of important information
+
+## 2. Hallucination
+
+### The Challenge
+Individual agents may generate plausible-sounding but incorrect information, especially when dealing with ambiguous or incomplete data.
+
+```mermaid
+graph TD
+    Input[Ambiguous Input] --> Agent[AI Agent]
+    Agent --> Valid[Valid Output]
+    Agent --> Hallucination[Hallucinated Output]
+    style Hallucination fill:#ff9999
+```
+
+### Impact
+- Unreliable information generation
+- Reduced trust in system outputs
+- Potential for misleading decisions
+- Need for extensive verification
+
+## 3. Single Task Execution
+
+### The Challenge
+Most individual agents are optimized for specific tasks and struggle with multi-tasking or adapting to new requirements.
+
+```mermaid
+graph LR
+    Task1[Task A] --> Agent1[Agent A]
+    Task2[Task B] --> Agent2[Agent B]
+    Task3[Task C] --> Agent3[Agent C]
+    Agent1 --> Output1[Output A]
+    Agent2 --> Output2[Output B]
+    Agent3 --> Output3[Output C]
+```
+
+### Impact
+- Limited flexibility
+- Inefficient resource usage
+- Complex integration requirements
+- Reduced adaptability
+
+## 4. Lack of Collaboration
+
+### The Challenge
+Individual agents operate in isolation, unable to share insights or coordinate actions with other agents.
+
+```mermaid
+graph TD
+    A1[Agent 1] --> O1[Output 1]
+    A2[Agent 2] --> O2[Output 2]
+    A3[Agent 3] --> O3[Output 3]
+    style A1 fill:#f9f,stroke:#333
+    style A2 fill:#f9f,stroke:#333
+    style A3 fill:#f9f,stroke:#333
+```
+
+### Impact
+- No knowledge sharing
+- Duplicate effort
+- Missed optimization opportunities
+- Limited problem-solving capabilities
+
+## 5. Accuracy Issues
+
+### The Challenge
+Individual agents may produce inaccurate results due to:
+- Limited training data
+- Model biases
+- Lack of cross-validation
+- Incomplete context understanding
+
+```mermaid
+graph LR
+    Input[Input Data] --> Processing[Processing]
+    Processing --> Accurate[Accurate Output]
+    Processing --> Inaccurate[Inaccurate Output]
+    style Inaccurate fill:#ff9999
+```
+
+## 6. Processing Speed Limitations
+
+### The Challenge
+Individual agents may experience:
+- Slow response times
+- Resource constraints
+- Limited parallel processing
+- Bottlenecks in complex tasks
+
+```mermaid
+graph TD
+    Input[Input] --> Queue[Processing Queue]
+    Queue --> Processing[Sequential Processing]
+    Processing --> Delay[Processing Delay]
+    Delay --> Output[Delayed Output]
+```
+
+## Best Practices for Mitigation
+
+1. **Use Multi-Agent Systems**
+   - Distribute tasks across agents
+   - Enable parallel processing
+   - Implement cross-validation
+   - Foster collaboration
+
+2. **Implement Verification**
+   - Cross-check results
+   - Use consensus mechanisms
+   - Monitor accuracy metrics
+   - Track performance
+
+3. **Optimize Resource Usage**
+   - Balance load distribution
+   - Cache frequent operations
+   - Implement efficient queuing
+   - Monitor system health
+
+## Conclusion
+
+Understanding these limitations is crucial for:
+- Designing robust multi-agent systems
+- Implementing effective mitigation strategies
+- Optimizing system performance
+- Ensuring reliable outputs
+
+The next section explores how [Multi-Agent Architecture](architecture.md) addresses these limitations through collaborative approaches and specialized agent roles. 

docs/index.md

@@ -1,3 +1,89 @@
+---
+title: Multi-Agent LLM Systems Best Practices Guide
+description: A comprehensive guide to building and managing multi-agent Large Language Model (LLM) systems
+---
+
+# Multi-Agent LLM Systems Best Practices Guide
+
+Welcome to the comprehensive guide on building and managing multi-agent Large Language Model (LLM) systems. This documentation provides tactical insights, best practices, and practical solutions for implementing reliable and efficient multi-agent systems.
+
+## Overview
+
+Multi-agent LLM systems represent a paradigm shift in artificial intelligence, enabling complex problem-solving through collaborative intelligence. This guide will help you understand:
+
+- Why multi-agent systems are necessary
+- Common limitations and how to overcome them
+- Best practices for implementation
+- Communication protocols and error handling
+- Performance optimization techniques
+
+## Quick Navigation
+
+```mermaid
+graph LR
+    A[Start Here] --> B[Core Concepts]
+    A --> C[Best Practices]
+    A --> D[FAQ]
+    B --> E[Why Multi-Agent?]
+    B --> F[Limitations]
+    B --> G[Architecture]
+    C --> H[Implementation]
+    C --> I[Communication]
+    C --> J[Error Handling]
+    C --> K[Performance]
+```
+
+## Key Features
+
+- 🚀 **Comprehensive Coverage**: From basic concepts to advanced implementation details
+- 🔧 **Practical Examples**: Real-world scenarios and solutions
+- 📈 **Performance Optimization**: Tips and techniques for scaling
+- 🛡️ **Error Handling**: Robust protocols for system reliability
+- 🤝 **Communication Patterns**: Effective agent collaboration strategies
+
+## Getting Started
+
+1. Start with [Why Multi-Agent Systems?](concepts/why-multi-agent.md) to understand the fundamentals
+2. Review [Limitations of Individual Agents](concepts/limitations.md) to learn about common challenges
+3. Explore [Implementation Guide](best-practices/implementation.md) for practical setup instructions
+4. Check the [FAQ](faq.md) for quick answers to common questions
+
+## Core Principles
+
+1. **Reliability Through Collaboration**
+   - Multiple agents working together
+   - Cross-verification of results
+   - Redundancy for critical tasks
+
+2. **Efficient Communication**
+   - Clear protocols
+   - Minimal overhead
+   - Effective coordination
+
+3. **Scalable Architecture**
+   - Modular design
+   - Flexible deployment
+   - Resource optimization
+
+4. **Robust Error Handling**
+   - Graceful failure recovery
+   - Systematic error detection
+   - Proactive monitoring
+
+## Contributing
+
+We welcome contributions to this guide! Please see our [contribution guidelines](contributing.md) for more information on how to help improve this documentation.
+
+## Support
+
+If you need help or have questions:
+
+1. Check the [FAQ](faq.md) section
+2. Review [Tips & Troubleshooting](tips.md)
+3. Raise an issue on our GitHub repository
+
+Let's build better multi-agent systems together! 🚀
+
 # Welcome to Swarms Docs Home
 
 [![Join our Discord](https://img.shields.io/badge/Discord-Join%20our%20server-5865F2?style=for-the-badge&logo=discord&logoColor=white)](https://discord.gg/jM3Z6M9uMq) [![Subscribe on YouTube](https://img.shields.io/badge/YouTube-Subscribe-red?style=for-the-badge&logo=youtube&logoColor=white)](https://www.youtube.com/@kyegomez3242) [![Connect on LinkedIn](https://img.shields.io/badge/LinkedIn-Connect-blue?style=for-the-badge&logo=linkedin&logoColor=white)](https://www.linkedin.com/in/kye-g-38759a207/) [![Follow on X.com](https://img.shields.io/badge/X.com-Follow-1DA1F2?style=for-the-badge&logo=x&logoColor=white)](https://x.com/kyegomezb)

docs/mkdocs.yml

@@ -330,6 +330,7 @@ nav:
     - Swarms API Pricing in Chinese: "swarms_cloud/chinese_api_pricing.md"
     - Swarm Types: "swarms_cloud/swarm_types.md"
     - Swarms Cloud Subscription Tiers: "swarms_cloud/subscription_tiers.md"
+    - Swarms API Best Practices: "swarms_cloud/best_practices.md"
     - Swarm Ecosystem APIs:
       - MCS API: "swarms_cloud/mcs_api.md"
       # - CreateNow API: "swarms_cloud/create_api.md"

docs/swarms_cloud/best_practices.md

@@ -0,0 +1,231 @@
+# Swarms API Best Practices Guide
+
+This comprehensive guide outlines production-grade best practices for using the Swarms API effectively. Learn how to choose the right swarm architecture, optimize costs, and implement robust error handling.
+
+## Quick Reference Cards
+
+=== "Swarm Types"
+    
+    !!! info "Available Swarm Architectures"
+        
+        | Swarm Type | Best For | Use Cases |
+        |------------|----------|------------|
+        | `AgentRearrange` | Dynamic workflows | - Complex task decomposition<br>- Adaptive processing<br>- Multi-stage analysis |
+        | `MixtureOfAgents` | Diverse expertise | - Cross-domain problems<br>- Comprehensive analysis<br>- Multi-perspective tasks |
+        | `SpreadSheetSwarm` | Data processing | - Financial analysis<br>- Data transformation<br>- Batch calculations |
+        | `SequentialWorkflow` | Linear processes | - Document processing<br>- Step-by-step analysis<br>- Quality control |
+        | `ConcurrentWorkflow` | Parallel tasks | - Batch processing<br>- Independent analyses<br>- High-throughput needs |
+        | `GroupChat` | Collaborative solving | - Brainstorming<br>- Decision making<br>- Problem solving |
+        | `MultiAgentRouter` | Task distribution | - Load balancing<br>- Specialized processing<br>- Resource optimization |
+        | `AutoSwarmBuilder` | Automated setup | - Quick prototyping<br>- Simple tasks<br>- Testing |
+        | `HiearchicalSwarm` | Complex organization | - Project management<br>- Research analysis<br>- Enterprise workflows |
+        | `MajorityVoting` | Consensus needs | - Quality assurance<br>- Decision validation<br>- Risk assessment |
+
+=== "Cost Optimization"
+
+    !!! tip "Cost Management Strategies"
+        
+        | Strategy | Implementation | Impact |
+        |----------|----------------|---------|
+        | Batch Processing | Group related tasks | 20-30% cost reduction |
+        | Off-peak Usage | Schedule for 8 PM - 6 AM PT | 15-25% cost reduction |
+        | Token Optimization | Precise prompts, focused tasks | 10-20% cost reduction |
+        | Caching | Store reusable results | 30-40% cost reduction |
+        | Agent Optimization | Use minimum required agents | 15-25% cost reduction |
+
+=== "Error Handling"
+
+    !!! warning "Error Management Best Practices"
+        
+        | Error Code | Strategy | Implementation |
+        |------------|----------|----------------|
+        | 400 | Input Validation | Pre-request parameter checks |
+        | 401 | Auth Management | Regular key rotation, secure storage |
+        | 429 | Rate Limiting | Exponential backoff, request queuing |
+        | 500 | Resilience | Retry with backoff, fallback logic |
+        | 503 | High Availability | Multi-region setup, redundancy |
+
+## Choosing the Right Swarm Architecture
+
+### Decision Framework
+
+Use this framework to select the optimal swarm architecture for your use case:
+
+1. **Task Complexity Analysis**
+    - Simple tasks → `AutoSwarmBuilder`
+    
+    - Complex tasks → `HiearchicalSwarm` or `MultiAgentRouter`
+    
+    - Dynamic tasks → `AgentRearrange`
+
+2. **Workflow Pattern**
+    
+    - Linear processes → `SequentialWorkflow`
+    
+    - Parallel operations → `ConcurrentWorkflow`
+    
+    - Collaborative tasks → `GroupChat`
+
+3. **Domain Requirements**
+    
+    - Multi-domain expertise → `MixtureOfAgents`
+    
+    - Data processing → `SpreadSheetSwarm`
+    
+    - Quality assurance → `MajorityVoting`
+
+### Industry-Specific Recommendations
+
+=== "Finance"
+    
+    !!! example "Financial Applications"
+        
+        
+        - Risk Analysis: `HiearchicalSwarm`
+        
+        - Market Research: `MixtureOfAgents`
+        
+        - Trading Strategies: `ConcurrentWorkflow`
+        
+        - Portfolio Management: `SpreadSheetSwarm`
+
+=== "Healthcare"
+    
+    !!! example "Healthcare Applications"
+        
+        
+        - Patient Analysis: `SequentialWorkflow`
+        
+        - Research Review: `MajorityVoting`
+        
+        - Treatment Planning: `GroupChat`
+        
+        - Medical Records: `MultiAgentRouter`
+
+=== "Legal"
+    
+    !!! example "Legal Applications"
+        
+        
+        - Document Review: `SequentialWorkflow`
+        
+        - Case Analysis: `MixtureOfAgents`
+        
+        - Compliance Check: `HiearchicalSwarm`
+        
+        - Contract Analysis: `ConcurrentWorkflow`
+
+## Production Implementation Guide
+
+### Authentication Best Practices
+
+```python
+import os
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# Secure API key management
+API_KEY = os.getenv("SWARMS_API_KEY")
+if not API_KEY:
+    raise EnvironmentError("API key not found")
+
+# Headers with retry capability
+headers = {
+    "x-api-key": API_KEY,
+    "Content-Type": "application/json",
+}
+```
+
+### Robust Error Handling
+
+```python
+import backoff
+import requests
+from typing import Dict, Any
+
+class SwarmsAPIError(Exception):
+    """Custom exception for Swarms API errors"""
+    pass
+
+@backoff.on_exception(
+    backoff.expo,
+    (requests.exceptions.RequestException, SwarmsAPIError),
+    max_tries=5
+)
+def execute_swarm(payload: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Execute swarm with robust error handling and retries
+    """
+    try:
+        response = requests.post(
+            f"{BASE_URL}/v1/swarm/completions",
+            headers=headers,
+            json=payload,
+            timeout=30
+        )
+        
+        response.raise_for_status()
+        return response.json()
+        
+    except requests.exceptions.RequestException as e:
+        if e.response is not None:
+            if e.response.status_code == 429:
+                # Rate limit exceeded
+                raise SwarmsAPIError("Rate limit exceeded")
+            elif e.response.status_code == 401:
+                # Authentication error
+                raise SwarmsAPIError("Invalid API key")
+        raise SwarmsAPIError(f"API request failed: {str(e)}")
+```
+
+
+## Appendix
+
+### Common Patterns and Anti-patterns
+
+!!! success "Recommended Patterns"
+    
+    - Use appropriate swarm types for tasks
+    
+    - Implement robust error handling
+    
+    - Monitor and log executions
+    
+    - Cache repeated results
+    
+    - Rotate API keys regularly
+
+!!! danger "Anti-patterns to Avoid"
+    
+    
+    - Hardcoding API keys
+    
+    - Ignoring rate limits
+    
+    - Missing error handling
+    
+    
+    - Excessive agent count
+    
+    - Inadequate monitoring
+
+### Performance Benchmarks
+
+!!! note "Typical Performance Metrics"
+    
+    | Metric | Target Range | Warning Threshold |
+    |--------|--------------|-------------------|
+    | Response Time | < 2s | > 5s |
+    | Success Rate | > 99% | < 95% |
+    | Cost per Task | < $0.05 | > $0.10 |
+    | Cache Hit Rate | > 80% | < 60% |
+    | Error Rate | < 1% | > 5% |
+
+### Additional Resources
+
+!!! info "Useful Links"
+    
+    - [Swarms API Documentation](https://docs.swarms.world)
+    - [API Dashboard](https://swarms.world/platform/api-keys)

mkdocs.yml

@@ -0,0 +1,83 @@
+site_name: Multi-Agent LLM Systems Best Practices
+site_description: Comprehensive guide for building and managing multi-agent systems
+site_author: Swarms Team
+
+theme:
+  name: material
+  features:
+    - navigation.tabs
+    - navigation.sections
+    - navigation.expand
+    - navigation.top
+    - search.suggest
+    - search.highlight
+    - content.tabs.link
+    - content.code.annotation
+    - content.code.copy
+  language: en
+  palette:
+    - scheme: default
+      toggle:
+        icon: material/toggle-switch-off-outline 
+        name: Switch to dark mode
+      primary: teal
+      accent: purple 
+    - scheme: slate 
+      toggle:
+        icon: material/toggle-switch
+        name: Switch to light mode    
+      primary: teal
+      accent: lime
+  font:
+    text: Roboto
+    code: Roboto Mono
+  icon:
+    repo: fontawesome/brands/github
+
+markdown_extensions:
+  - pymdownx.highlight:
+      anchor_linenums: true
+  - pymdownx.inlinehilite
+  - pymdownx.snippets
+  - admonition
+  - pymdownx.arithmatex:
+      generic: true
+  - footnotes
+  - pymdownx.details
+  - pymdownx.superfences:
+      custom_fences:
+        - name: mermaid
+          class: mermaid
+          format: !!python/name:pymdownx.superfences.fence_code_format
+  - pymdownx.mark
+  - attr_list
+  - pymdownx.emoji:
+      emoji_index: !!python/name:materialx.emoji.twemoji
+      emoji_generator: !!python/name:materialx.emoji.to_svg
+
+plugins:
+  - search
+  - minify:
+      minify_html: true
+
+extra:
+  social:
+    - icon: fontawesome/brands/github-alt
+      link: https://github.com/yourusername/multi-agent-best-practices
+
+nav:
+  - Home: index.md
+  - Core Concepts:
+    - Why Multi-Agent Systems?: concepts/why-multi-agent.md
+    - Limitations of Individual Agents: concepts/limitations.md
+    - Multi-Agent Architecture: concepts/architecture.md
+  - Best Practices:
+    - Implementation Guide: best-practices/implementation.md
+    - Communication Protocols: best-practices/communication.md
+    - Error Handling: best-practices/error-handling.md
+    - Performance Optimization: best-practices/performance.md
+  - FAQ: faq.md
+  - Tips & Troubleshooting: tips.md
+  - Glossary: swarms/glossary.md
+
+copyright: Copyright © 2024 Multi-Agent LLM Systems