MULTI-AGENT SYSTEMS:
AGENTS MILKAR KAAM KAREIN.

1. Sequential Pipeline
 ✓ Agents ek ke baad ek kaam karte hain
 ✓ Output ek agent ka input ban jaata hai
 ✓ Example: Research ✓ Write ✓ Review ✓ Publish
 ✓ Simple hai, lekin slow

2. Parallel Processing
 ✓ Multiple agents ek saath kaam karte hain
 ✓ Har agent apna task independently karta hai
 ✓ Example: Ek hi data ko 3 agents alag angle se analyze karein
 ✓ Fast hai, lekin coordination mushkil

3. Hierarchical (Manager Pattern)
 ✓ Ek manager agent hota hai jo baaki ko coordinate karta hai
 ✓ Manager task distribute karta hai, results collect karta hai
 ✓ Example: CEO ✓ Managers ✓ Workers
 ✓ Scalable hai, lekin manager bottleneck ban sakta hai

# Multi-agent system
class Agent:
 def __init__(self, name, role):
 self.name = name
 self.role = role
 
 def work(self, task):
 return f"{self.name} ({self.role}) processing: {task}"

class MultiAgentSystem:
 def __init__(self):
 self.agents = {}
 
 def add_agent(self, agent):
 self.agents[agent.name] = agent
 
 def assign_task(self, task, agent_name=None):
 if agent_name and agent_name in self.agents:
 return self.agents[agent_name].work(task)
 
 # Assign to best agent based on role
 for agent in self.agents.values():
 if agent.role in task.lower():
 return agent.work(task)
 return "No suitable agent found"
 
 def collaborate(self, task):
 results = []
 for agent in self.agents.values():
 results.append(agent.work(task))
 return results

# Create system
system = MultiAgentSystem()
system.add_agent(Agent("Researcher", "research"))
system.add_agent(Agent("Writer", "writing"))
system.add_agent(Agent("Reviewer", "review"))

print(system.collaborate("Write a blog about AI"))

# Orchestrator pattern
class Orchestrator:
 def __init__(self):
 self.agents = {}
 self.pipeline = []
 
 def register_agent(self, name, agent):
 self.agents[name] = agent
 
 def set_pipeline(self, pipeline):
 self.pipeline = pipeline
 
 def execute(self, task):
 current_input = task
 results = []
 
 for agent_name in self.pipeline:
 agent = self.agents[agent_name]
 result = agent.work(current_input)
 results.append({
 "agent": agent_name,
 "input": current_input,
 "output": result
 })
 current_input = result
 
 return results

# Research ✓ Write ✓ Review pipeline
orchestrator = Orchestrator()
orchestrator.register_agent("researcher", Agent("Researcher", "research"))
orchestrator.register_agent("writer", Agent("Writer", "writing"))
orchestrator.register_agent("reviewer", Agent("Reviewer", "review"))
orchestrator.set_pipeline(["researcher", "writer", "reviewer"])

results = orchestrator.execute("Write about AI agents")
for r in results:
 print(f"{r['agent']}: {r['output']}")

# Agent communication via messages
class Message:
 def __init__(self, sender, receiver, content, msg_type="info"):
 self.sender = sender
 self.receiver = receiver
 self.content = content
 self.msg_type = msg_type

class CommunicatingAgent:
 def __init__(self, name, role):
 self.name = name
 self.role = role
 self.inbox = []
 self.outbox = []
 
 def receive(self, message):
 self.inbox.append(message)
 return f"{self.name} received: {message.content}"
 
 def send(self, receiver_name, content, msg_type="info"):
 msg = Message(self.name, receiver_name, content, msg_type)
 self.outbox.append(msg)
 return msg
 
 def process_inbox(self):
 results = []
 for msg in self.inbox:
 result = self.work(msg.content)
 results.append(result)
 self.inbox.clear()
 return results
 
 def work(self, task):
 return f"{self.name} ({self.role}) done: {task}"

# Example communication
researcher = CommunicatingAgent("Researcher", "research")
writer = CommunicatingAgent("Writer", "writing")

# Researcher sends findings to writer
msg = researcher.send("Writer", "AI agents autonomous hain")
print(writer.receive(msg))

# Writer processes and sends to reviewer
writer_results = writer.process_inbox()
print(writer_results)

# Consensus mechanism
class ConsensusSystem:
 def __init__(self):
 self.agents = {}
 self.votes = {}
 
 def add_agent(self, name, weight=1):
 self.agents[name] = weight
 
 def vote(self, agent_name, decision):
 if agent_name in self.agents:
 self.votes[decision] = self.votes.get(decision, 0) + self.agents[agent_name]
 
 def get_consensus(self):
 if not self.votes:
 return "No votes yet"
 
 # Weighted voting
 max_votes = max(self.votes.values())
 winners = [d for d, v in self.votes.items() if v == max_votes]
 
 if len(winners) == 1:
 return f"Consensus: {winners[0]} (votes: {max_votes})"
 else:
 return f"Tie between: {', '.join(winners)}"
 
 def reset(self):
 self.votes = {}

# Example: Choose best approach
consensus = ConsensusSystem()
consensus.add_agent("Researcher", weight=2) # Expert has more weight
consensus.add_agent("Writer", weight=1)
consensus.add_agent("Reviewer", weight=1)

consensus.vote("Researcher", "approach_A")
consensus.vote("Writer", "approach_B")
consensus.vote("Reviewer", "approach_A")

print(consensus.get_consensus()) # approach_A wins