🦜🕸️LangGraph for Java. A library for building stateful, multi-agents applications with LLMs, built for work with langchain4j
It is a porting of original LangGraph from LangChain AI project in Java fashion
Date | Release | info |
---|---|---|
Jul 19, 2024 | 1.0-SNAPSHOT |
Add support of an embed Playground Webapp able to run Langgrap4j flow - issue #9 |
Jun 21, 2024 | 1.0-SNAPSHOT |
Add support of Mermaid diagram generation - issue #5 |
Jun 19, 2024 | 1.0-SNAPSHOT |
Add adaptive rag sample |
Jun 10, 2024 | 1.0-SNAPSHOT |
Refactoring how generate graph representation (plantuml) |
May 20, 2024 | 1.0-SNAPSHOT |
Add "Image To PlantUML Diagram" sample |
May 18, 2024 | 1.0-SNAPSHOT |
Add getGraph() method to CompiledGraph to return a PlantUML representation of your Graph |
👉 Currently are available only the developer SNAPSHOTs
Maven
<dependency>
<groupId>org.bsc.langgraph4j</groupId>
<artifactId>langgraph4j-jdk8</artifactId>
<version>1.0-SNAPSHOT</version>
<dependency>
The main type of graph in langgraph
is the StatefulGraph
. This graph is parameterized by a state object that it passes around to each node.
Each node then returns operations to update that state. These operations can either SET specific attributes on the state (e.g. overwrite the existing values) or ADD to the existing attribute.
Whether to set or add is denoted by initialize the property with a AppendableValue
. The State must inherit from AgentState
base class (that essentially is a Map
wrapper).
public class AgentState {
public AgentState( Map<String,Object> initData ) { ... };
public final java.util.Map<String,Object> data() { ... };
public final <T> Optional<T> value(String key) { ... };
public final <T> AppendableValue<T> appendableValue(String key ) { ... };
}
We now need to define a few different nodes in our graph. In langgraph
, a node is an async/sync function that accept an AgentState
as argument and returns a (partial) state update. There are two main nodes we need for this:
- The agent: responsible for deciding what (if any) actions to take.
- A function to invoke tools: if the agent decides to take an action, this node will then execute that action.
/**
* Represents an asynchronous node action that operates on an agent state and returns state update.
*
* @param <S> the type of the agent state
*/
@FunctionalInterface
public interface AsyncNodeAction<S extends AgentState> extends Function<S, CompletableFuture<Map<String, Object>>> {
CompletableFuture<Map<String, Object>> apply(S t);
/**
* Creates an asynchronous node action from a synchronous node action.
*/
static <S extends AgentState> AsyncNodeAction<S> node_async(NodeAction<S> syncAction) { ... }
}
We will also need to define some edges. Some of these edges may be conditional. The reason they are conditional is that based on the output of a node, one of several paths may be taken. The path that is taken is not known until that node is run (the LLM decides).
- Conditional Edge: after the agent is called, we should either:
- If the agent said to take an action, then the function to invoke tools should be called
- If the agent said that it was finished, then it should finish
- Normal Edge: after the tools are invoked, it should always go back to the agent to decide what to do next
/**
* Represents an asynchronous edge action that operates on an agent state and returns a new route.
*
* @param <S> the type of the agent state
*/
public interface AsyncEdgeAction<S extends AgentState> extends Function<S, CompletableFuture<String>> {
CompletableFuture<String> apply(S t);
/**
* Creates an asynchronous edge action from a synchronous edge action.
*/
static <S extends AgentState> AsyncEdgeAction<S> edge_async(EdgeAction<S> syncAction ) { ... }
}
We can now put it all together and define the graph! (see example below)
Like default use case proposed in LangGraph blog, We have ported AgentExecutor implementation from langchain using LangGraph4j. In the agents project's module, you can the complete working code with tests. Feel free to checkout and use it as a reference.
Below you can find a piece of code of the AgentExecutor
to give you an idea of how is has built in langgraph style.
public static class State implements AgentState {
public State(Map<String, Object> initData) {
super(initData);
}
Optional<String> input() {
return value("input");
}
Optional<AgentOutcome> agentOutcome() {
return value("agent_outcome");
}
AppendableValue<IntermediateStep> intermediateSteps() {
return appendableValue("intermediate_steps");
}
}
var toolInfoList = ToolInfo.fromList( objectsWithTools );
final List<ToolSpecification> toolSpecifications = toolInfoList.stream()
.map(ToolInfo::specification)
.toList();
var agentRunnable = Agent.builder()
.chatLanguageModel(chatLanguageModel)
.tools( toolSpecifications )
.build();
var workflow = new StateGraph<>(State::new);
workflow.setEntryPoint("agent");
workflow.addNode( "agent", node_async( state ->
runAgent(agentRunnable, state)) // see implementation in the repo code
);
workflow.addNode( "action", node_async( state ->
executeTools(toolInfoList, state)) // see implementation in the repo code
);
workflow.addConditionalEdge(
"agent",
edge_async( state -> {
if (state.agentOutcome().map(AgentOutcome::finish).isPresent()) {
return "end";
}
return "continue";
}),
Map.of("continue", "action", "end", END)
);
workflow.addEdge("action", "agent");
var app = workflow.compile();
return app.stream( inputs );
It is available an embed playground webapp able to run a Langgraph4j workflow in visual way.
<dependency>
<groupId>org.bsc.langgraph4j</groupId>
<artifactId>langgraph4j-server-jetty</artifactId>
<version>1.0-SNAPSHOT</version>
<dependency>
StateGraph<AgentState> workflow = new StateGraph<>( AgentState::new );
// define your workflow
...
// compile workflow
CompiledGraph<AgentState> app = workflow.compile();
// connect playgroud webapp to workflow
var server = LangGraphStreamingServer.builder()
.port(8080)
.title("LANGGRAPH4j - TEST")
.addInputStringArg("input")
.build(app);
// start playground
server.start().join();