# Traditional Approach - Single Model
class TraditionalChatbot:
    def __init__(self):
        self.model = OpenAI(model="gpt-3.5-turbo")
    
    def respond(self, query: str) -> str:
        # Generic response for all queries
        return self.model.chat.completions.create(
            messages=[{"role": "user", "content": query}]
        ).choices[0].message.content
 
# Modern Approach - Specialized Agents
class ECommerceAgent(BaseAgent):
    def __init__(self):
        super().__init__(
            name="ecommerce_specialist",
            model="gpt-4-turbo",
            tools=[self.search_products, self.check_inventory, self.process_orders]
        )
    
    @function_tool
    def search_products(self, query: str, category: str = None) -> dict:
        """Search products with advanced filtering and ranking"""
        # Specialized product search logic
        return {
            "products": self.product_db.search(query, category),
            "recommendations": self.ml_engine.get_similar_products(query),
            "availability": self.inventory_service.check_stock()
        }

class RecommendationAgent(BaseAgent):
    def __init__(self):
        super().__init__(
            name="recommendation_engine",
            description="Provides personalized product recommendations"
        )
    
    @function_tool
    def get_personalized_recommendations(
        self, 
        user_id: str, 
        category: str = None,
        price_range: tuple = None
    ) -> dict:
        """Generate personalized recommendations using ML models"""
        
        # Fetch user behavior data
        user_profile = self.analytics_service.get_user_profile(user_id)
        
        # Apply ML recommendation engine
        recommendations = self.ml_service.predict_preferences(
            user_profile=user_profile,
            category_filter=category,
            price_filter=price_range
        )
        
        return {
            "recommendations": recommendations,
            "confidence_scores": self.ml_service.get_confidence_scores(),
            "explanation": self.generate_explanation(user_profile, recommendations)
        }

import asyncio
from typing import List, Dict, Any
 
class AsyncAgentOrchestrator:
    def __init__(self):
        self.agents = {
            'order': OrderAgent(),
            'recommendation': RecommendationAgent(),
            'support': SupportAgent()
        }
        self.cache = RedisCache()
    
    async def process_query(self, query: str, user_context: Dict) -> Dict[str, Any]:
        # Check cache first
        cache_key = self.generate_cache_key(query, user_context)
        cached_response = await self.cache.get(cache_key)
        
        if cached_response:
            return cached_response
        
        # Determine relevant agents
        relevant_agents = await self.route_query(query, user_context)
        
        # Process with multiple agents concurrently
        tasks = [
            agent.process_async(query, user_context) 
            for agent in relevant_agents
        ]
        
        agent_responses = await asyncio.gather(*tasks, return_exceptions=True)
        
        # Aggregate and synthesize responses
        final_response = await self.synthesize_responses(agent_responses)
        
        # Cache for future use
        await self.cache.set(cache_key, final_response, ttl=3600)
        
        return final_response

class CollaborativeAgentSystem:
    def __init__(self):
        self.agents = self.initialize_agents()
        self.collaboration_engine = CollaborationEngine()
    
    async def handle_complex_query(self, query: str) -> str:
        # Primary agent analyzes the query
        primary_agent = await self.select_primary_agent(query)
        initial_analysis = await primary_agent.analyze(query)
        
        # Determine if collaboration is needed
        if initial_analysis.requires_collaboration:
            # Request assistance from specialized agents
            collaborating_agents = await self.select_collaborators(
                query, initial_analysis
            )
            
            # Coordinate multi-agent response
            collaborative_response = await self.collaboration_engine.coordinate(
                primary_agent=primary_agent,
                collaborators=collaborating_agents,
                query=query,
                context=initial_analysis
            )
            
            return collaborative_response
        
        return await primary_agent.respond(query)

# AVOID: Synchronous agent calls
def bad_agent_orchestration(query):
    agent1_response = agent1.process(query)  # Blocking
    agent2_response = agent2.process(query)  # Blocking
    return combine_responses(agent1_response, agent2_response)
 
# PREFER: Asynchronous agent orchestration
async def good_agent_orchestration(query):
    agent1_task = asyncio.create_task(agent1.process_async(query))
    agent2_task = asyncio.create_task(agent2.process_async(query))
    
    responses = await asyncio.gather(agent1_task, agent2_task)
    return await combine_responses_async(responses)

# Recommended project structure
project/
├── agents/
│   ├── __init__.py
│   ├── base_agent.py
│   ├── specialized_agents/
│   │   ├── ecommerce_agent.py
│   │   ├── support_agent.py
│   │   └── recommendation_agent.py
├── orchestration/
│   ├── router.py
│   ├── context_manager.py
│   └── response_synthesizer.py
├── tools/
│   ├── database_tools.py
│   ├── api_integrations.py
│   └── ml_services.py
├── config/
│   ├── settings.py
│   └── agent_configs.py
├── tests/
│   ├── agent_tests/
│   ├── integration_tests/
│   └── performance_tests/
└── main.py