RANA vs MetaGPT

from metagpt.roles import ProductManager, Architect, Engineer
from metagpt.team import Team
from metagpt.config import Config

config = Config.default()

team = Team()
team.hire([
    ProductManager(),
    Architect(),
    Engineer(),
])

team.invest(investment=10.0)
team.run_project(idea="Build a weather app")

# Complex setup with roles, actions, and memories
# Requires understanding MetaGPT's role-based architecture

import { createTeam, createOrchestrator } from '@rana/agents';

const orchestrator = createOrchestrator();

const { execute } = createTeam({
  coordinator: {
    id: 'pm',
    name: 'Product Manager',
    capabilities: ['planning', 'coordination'],
  },
  workers: [
    { id: 'architect', name: 'Architect', capabilities: ['design'] },
    { id: 'engineer', name: 'Engineer', capabilities: ['code'] },
  ],
});

const result = await execute({
  taskId: 'weather-app',
  description: 'Build a weather app',
  input: { idea: 'weather app with forecasts' },
});

from metagpt.roles import Role
from metagpt.actions import Action
from metagpt.messages import Message

class CustomAction(Action):
    name: str = "CustomAction"

    async def run(self, messages: list[Message]) -> str:
        # Process messages
        return "result"

class CustomRole(Role):
    name: str = "CustomRole"
    profile: str = "A custom agent"

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.set_actions([CustomAction()])

    async def _act(self) -> Message:
        result = await self.todo.run(self.rc.memory.get())
        return Message(content=result, role=self.profile)

# Requires understanding OOP patterns and async execution

import { AgentOrchestrator } from '@rana/agents';

const orchestrator = new AgentOrchestrator();

// Register agents
orchestrator.registerAgent({
  id: 'custom-agent',
  name: 'Custom Agent',
  capabilities: ['custom-task'],
});

// Simple message passing
await orchestrator.sendMessage('custom-agent', {
  type: 'task',
  content: { action: 'process', data: input },
});

// Listen for responses
orchestrator.on((event) => {
  if (event.type === 'message') {
    console.log('Agent response:', event.message);
  }
});

from metagpt.environment import Environment
from metagpt.memory import Memory, LongTermMemory

# MetaGPT uses environment and memory classes
env = Environment()

# Memory is tied to roles
class MyRole(Role):
    def __init__(self):
        super().__init__()
        self.rc.memory = Memory()
        self.rc.long_term_memory = LongTermMemory()

    async def _observe(self):
        # Observe messages from environment
        await super()._observe()

    async def _think(self):
        # Access memory for context
        memories = self.rc.memory.get()
        # Complex memory management

import { SharedStateManager } from '@rana/agents';

const stateManager = new SharedStateManager({ taskCount: 0 });

// Simple state updates
await stateManager.update({
  type: 'set',
  key: 'currentTask',
  value: 'weather-app',
});

// Transactions for consistency
await stateManager.transaction('tx-1', async (state) => {
  state.taskCount++;
  state.lastUpdated = Date.now();
  return state;
});

// Subscribe to changes
stateManager.subscribe((state) => {
  console.log('State changed:', state);
});

# MetaGPT doesn't have built-in consensus mechanisms
# You would need to implement custom logic:

class ConsensusRole(Role):
    async def vote(self, proposal):
        # Manual implementation needed
        pass

# Coordinate multiple roles manually
results = []
for role in team.roles:
    vote = await role.vote(proposal)
    results.append(vote)

# Count votes manually
consensus = sum(results) > len(results) / 2

import { createConsensusGroup } from '@rana/agents';

const { vote } = createConsensusGroup([
  { id: 'reviewer-1', name: 'Reviewer 1', capabilities: ['review'] },
  { id: 'reviewer-2', name: 'Reviewer 2', capabilities: ['review'] },
  { id: 'reviewer-3', name: 'Reviewer 3', capabilities: ['review'] },
], {
  quorum: 2,
  votingStrategy: 'majority',
});

const result = await vote({
  taskId: 'approve-design',
  description: 'Approve the weather app design',
  input: { design: designDoc },
});

console.log(result.consensusReached); // true/false
console.log(result.votes); // { approve: 2, reject: 1 }