Agentic Architecture

utility to render graph respresentation in PlantUML

import net.sourceforge.plantuml.SourceStringReader;
import net.sourceforge.plantuml.FileFormatOption;
import net.sourceforge.plantuml.FileFormat;
import org.bsc.langgraph4j.GraphRepresentation;

void displayDiagram( GraphRepresentation representation ) throws IOException { 
    
    var reader = new SourceStringReader(representation.getContent());

    try(var imageOutStream = new java.io.ByteArrayOutputStream()) {

        var description = reader.outputImage( imageOutStream, 0, new FileFormatOption(FileFormat.PNG));

        var imageInStream = new java.io.ByteArrayInputStream(  imageOutStream.toByteArray() );

        var image = javax.imageio.ImageIO.read( imageInStream );

        display(  image );

    }
}

Initialize Log

var lm = java.util.logging.LogManager.getLogManager();
lm.checkAccess(); 
try( var file = new java.io.FileInputStream("./logging.properties")) {
    lm.readConfiguration( file );
}
var log = org.slf4j.LoggerFactory.getLogger("multi-agent-supervisor");

Graph State

import org.bsc.langgraph4j.prebuilt.MessagesState;
import dev.langchain4j.data.message.ChatMessage;
import java.util.Optional;

class State extends MessagesState<ChatMessage> {

    public Optional<String> next() {
        return this.value("next");
    }

    public State(Map<String, Object> initData) {
        super( initData  );
    }
}

Create Serializer

This is important for supporting persistent state across graph execution

import org.bsc.langgraph4j.langchain4j.serializer.std.ChatMesssageSerializer;
import org.bsc.langgraph4j.langchain4j.serializer.std.ToolExecutionRequestSerializer;
import org.bsc.langgraph4j.serializer.std.ObjectStreamStateSerializer;
import dev.langchain4j.agent.tool.ToolExecutionRequest;

class StateSerializer extends ObjectStreamStateSerializer<State> {

    public StateSerializer() {
        super(State::new);

        mapper().register(ToolExecutionRequest.class, new ToolExecutionRequestSerializer());
        mapper().register(ChatMessage.class, new ChatMesssageSerializer());
    }
}

Create Supervisor Agent

⚠️ Since this is just a POC the tool is mocked ⚠️

import dev.langchain4j.agent.tool.P;
import dev.langchain4j.agent.tool.Tool;
import dev.langchain4j.model.output.structured.Description;
import dev.langchain4j.service.V;
import dev.langchain4j.service.SystemMessage;
import dev.langchain4j.service.AiServices;
import dev.langchain4j.data.message.AiMessage;
import dev.langchain4j.data.message.UserMessage;
import dev.langchain4j.model.chat.ChatLanguageModel;
import org.bsc.langgraph4j.action.NodeAction;
import java.util.concurrent.CompletableFuture;
import static java.lang.String.format;


class SupervisorAgent implements NodeAction<State> {

    static class Router {
        @Description("Worker to route to next. If no workers needed, route to FINISH.")
        String next;

        @Override
        public String toString() {
            return format( "Router[next: %s]",next);
        }
    }

    interface Service {
        @SystemMessage( """
                You are a supervisor tasked with managing a conversation between the following workers: {{members}}.
                Given the following user request, respond with the worker to act next.
                Each worker will perform a task and respond with their results and status.
                When finished, respond with FINISH.
                """)
        Router evaluate(@V("members") String members, @dev.langchain4j.service.UserMessage String userMessage);
    }

    final Service service;
    public final String[] members = {"researcher", "coder" };

    public SupervisorAgent(ChatLanguageModel model ) {

        service = AiServices.create( Service.class, model );
    }

    @Override
    public Map<String, Object> apply(State state) throws Exception {    
        
        var message = state.lastMessage().orElseThrow();

        var text = switch( message.type() ) {
            case USER -> ((UserMessage)message).singleText();
            case AI -> ((AiMessage)message).text();
            default -> throw new IllegalStateException("unexpected message type: " + message.type() );
        };

        var m = String.join(",", members);
        
        var result = service.evaluate( m, text );
        
        return Map.of( "next", result.next );
    }
}

Create Researcher Agent

⚠️ Since this is just a POC the tool is mocked ⚠️

class ResearchAgent implements NodeAction<State> {
    static class Tools {

        @Tool("""
        Use this to perform a research over internet
        """)
        String search(@P("internet query") String query) {
            log.info( "search query: '{}'", query );
            return """
            the games will be in Italy at Cortina '2026
            """;
        }
    }

    interface Service {
        String search(@dev.langchain4j.service.UserMessage  String query);
    }

    final Service service;

    public ResearchAgent( ChatLanguageModel model ) {
        service = AiServices.builder( Service.class )
                        .chatLanguageModel(model)
                        .tools( new Tools() )
                        .build();
    }
    @Override
    public Map<String, Object> apply(State state) throws Exception {
        var message = state.lastMessage().orElseThrow();
        var text = switch( message.type() ) {
            case USER -> ((UserMessage)message).singleText();
            case AI -> ((AiMessage)message).text();
            default -> throw new IllegalStateException("unexpected message type: " + message.type() );
        };
        var result = service.search( text );
        return Map.of( "messages", AiMessage.from(result) );

    }
}

Create Coder Agent

⚠️ Since this is just a POC the tool is mocked ⚠️

class CoderAgent implements NodeAction<State> {
    static class Tools {

        @Tool("""
            Use this to execute java code and do math. If you want to see the output of a value,
            you should print it out with `System.out.println(...);`. This is visible to the user.""")
        String search(@P("coder request") String request) {
            log.info( "CoderTool request: '{}'", request );
            return """
            2
            """;
        }
    }

    interface Service {
        String evaluate(@dev.langchain4j.service.UserMessage String code);
    }

    final Service service;

    public CoderAgent( ChatLanguageModel model ) throws Exception {
        service = AiServices.builder( Service.class )
                .chatLanguageModel(model)
                .tools( new Tools() )
                .build();
    }
    @Override
    public Map<String, Object> apply(State state) {
        var message = state.lastMessage().orElseThrow();
        var text = switch( message.type() ) {
            case USER -> ((UserMessage)message).singleText();
            case AI -> ((AiMessage)message).text();
            default -> throw new IllegalStateException("unexpected message type: " + message.type() );
            };
        var result = service.evaluate( text );
        return Map.of( "messages", AiMessage.from(result) );

    }
}

Initialize OLLAMA Models

import dev.langchain4j.model.ollama.OllamaChatModel;

final ChatLanguageModel model = OllamaChatModel.builder()
    .baseUrl( "http://localhost:11434" )
    .temperature(0.0)
    .logRequests(true)
    .logResponses(true)
    .format( "json" )
    .modelName("deepseek-r1:14b")
    .build();

final ChatLanguageModel modelWithTool = OllamaChatModel.builder()
    .baseUrl( "http://localhost:11434" )
    .temperature(0.0)
    .logRequests(true)
    .logResponses(true)
    .modelName("llama3.1:latest")
    .build();

Define Graph

import org.bsc.langgraph4j.StateGraph;
import static org.bsc.langgraph4j.StateGraph.END;
import static org.bsc.langgraph4j.StateGraph.START;
import static org.bsc.langgraph4j.action.AsyncEdgeAction.edge_async;
import static org.bsc.langgraph4j.action.AsyncNodeAction.node_async;


var supervisor = new SupervisorAgent(model);
var coder = new CoderAgent(modelWithTool);
var researcher = new ResearchAgent(modelWithTool);

var workflow = new StateGraph<>( State.SCHEMA, new StateSerializer() )
.addNode( "supervisor", node_async(supervisor)) 
.addNode( "coder", node_async(coder) )
.addNode( "researcher",node_async(researcher) )
.addEdge( START, "supervisor")
.addConditionalEdges( "supervisor",
        edge_async( state ->
            state.next().orElseThrow()
        ), Map.of(
                "FINISH", END,
                "coder", "coder",
                "researcher", "researcher"
        ))
.addEdge( "coder", "supervisor")
.addEdge( "researcher", "supervisor")
;

Display StateGraph

var representation = workflow.getGraph( GraphRepresentation.Type.PLANTUML, "sub graph", false );

displayDiagram( representation );

Run Graph (Supervisor -> coder)

var graph = workflow.compile();

for( var event : graph.stream( Map.of( "messages", UserMessage.from("what are the result of 1 + 1 ?"))) ) {

    log.info( "{}", event );
}

START 
NodeOutput{node=__START__, state={messages=[UserMessage { name = null contents = [TextContent { text = "what are the result of 1 + 1 ?" }] }]}} 
CoderTool request: 'System.out.println(1+1);' 
NodeOutput{node=supervisor, state={next=coder, messages=[UserMessage { name = null contents = [TextContent { text = "what are the result of 1 + 1 ?" }] }]}} 
NodeOutput{node=coder, state={next=coder, messages=[UserMessage { name = null contents = [TextContent { text = "what are the result of 1 + 1 ?" }] }, AiMessage { text = "The result of 1 + 1 is 2." toolExecutionRequests = null }]}} 
NodeOutput{node=supervisor, state={next=FINISH, messages=[UserMessage { name = null contents = [TextContent { text = "what are the result of 1 + 1 ?" }] }, AiMessage { text = "The result of 1 + 1 is 2." toolExecutionRequests = null }]}} 
NodeOutput{node=__END__, state={next=FINISH, messages=[UserMessage { name = null contents = [TextContent { text = "what are the result of 1 + 1 ?" }] }, AiMessage { text = "The result of 1 + 1 is 2." toolExecutionRequests = null }]}} 

Run Graph (Supervisor -> researcher)

var graph = workflow.compile();

for( var event : graph.stream( Map.of( "messages", UserMessage.from("where are next winter olympic games ?"))) ) {

    log.info( "{}", event );
}

START 
NodeOutput{node=__START__, state={messages=[UserMessage { name = null contents = [TextContent { text = "where are next winter olympic games ?" }] }]}} 
search query: 'next winter olympic games location' 
NodeOutput{node=supervisor, state={next=researcher, messages=[UserMessage { name = null contents = [TextContent { text = "where are next winter olympic games ?" }] }]}} 
NodeOutput{node=researcher, state={next=researcher, messages=[UserMessage { name = null contents = [TextContent { text = "where are next winter olympic games ?" }] }, AiMessage { text = "The next Winter Olympic Games will take place in Cortina d'Ampezzo, Italy in 2026." toolExecutionRequests = null }]}} 
NodeOutput{node=supervisor, state={next=FINISH, messages=[UserMessage { name = null contents = [TextContent { text = "where are next winter olympic games ?" }] }, AiMessage { text = "The next Winter Olympic Games will take place in Cortina d'Ampezzo, Italy in 2026." toolExecutionRequests = null }]}} 
NodeOutput{node=__END__, state={next=FINISH, messages=[UserMessage { name = null contents = [TextContent { text = "where are next winter olympic games ?" }] }, AiMessage { text = "The next Winter Olympic Games will take place in Cortina d'Ampezzo, Italy in 2026." toolExecutionRequests = null }]}}