🗨️ MeshChat - Distributed Multi-Agent Chat System

@MeshAgent
public class ChatAgent extends Agent {
    
    @Inject
    LLMService llmService;
    
    @Inject
    KafkaProducer<String, String> producer;
    
    private Map<String, Conversation> conversations;
    
    @Override
    public void initialize(AgentContext context) {
        this.setMeshConfig(new MeshConfig()
            .nodeId("chat-agent-" + UUID.randomUUID())
            .kafkaBrokers("localhost:9092")
            .topics("chat.messages", "chat.users")
        );
        
        context.subscribe("chat.messages", this::handleMessage);
        context.subscribe("chat.users", this::handleUserEvent);
    }
    
    private void handleMessage(Message message) {
        ChatMessage chatMsg = deserialize(message);
        
        // Get or create conversation
        Conversation conv = conversations.computeIfAbsent(
            chatMsg.getConversationId(),
            k -> new Conversation(k)
        );
        
        // Add to conversation
        conv.addMessage(chatMsg);
        
        // Generate response using LLM
        String response = llmService.chat(
            chatMsg.getContent(),
            new ChatConfig()
                .model("gpt-4")
                .context(conv.getContext())
        );
        
        // Publish response
        producer.send("chat.messages", response);
    }
    
    private void handleUserEvent(Message message) {
        UserEvent event = deserialize(message);
        // Handle user join/leave/status
    }
}

@Path("/api/chat")
public class ChatResource {
    
    @Inject
    AgentContext agentContext;
    
    @POST
    @Path("/send")
    public Response sendMessage(ChatMessage message) {
        // Publish to Kafka
        agentContext.publish("chat.messages", serialize(message));
        
        return Response.ok()
            .entity(new Response("Message sent"))
            .build();
    }
    
    @GET
    @Path("/conversation/{id}")
    public Response getConversation(@PathParam("id") String id) {
        // Retrieve conversation from agent
        Conversation conv = getConversation(id);
        
        return Response.ok()
            .entity(conv)
            .build();
    }
}

// Automatic migration based on load
@Scheduled(every = "30s")
public void checkLoadAndMigrate() {
    double loadFactor = this.getLoadFactor();
    
    if (loadFactor > 0.8) {
        // High load - migrate to another node
        String targetNode = findLeastLoadedNode();
        this.migrateToNode(targetNode);
    } else if (loadFactor < 0.2) {
        // Low load - consolidate
        String targetNode = findConsolidationNode();
        this.migrateToNode(targetNode);
    }
}

private String findLeastLoadedNode() {
    return meshNetwork.getNodes().stream()
        .min(Comparator.comparingDouble(Node::getLoadFactor))
        .map(Node::getId)
        .orElse(null);
}

// Message routing based on load
public void routeMessage(ChatMessage message) {
    // Find agent with lowest load
    ChatAgent agent = agents.stream()
        .min(Comparator.comparingDouble(Agent::getLoadFactor))
        .orElse(this);
    
    // Send to agent
    agent.handleMessage(message);
}