All Classes and Interfaces
Class
Description
AdaptiveRag
Represents the state of our graph.
Represents an agent that can process chat messages and execute actions using specified tools.
Represents result of an action performed by an agent.
Interface representing an Agent Executor.
Represents the core component responsible for executing agent logic.
Represents an action with a tool call and associated log details.
Represents the completion of a process, encapsulating any relevant return values as key-value pairs in a map.
Builder class for constructing a graph of agent execution.
Represents the outcome of an action with a specific finish status.
Enum representing different serializers for the agent state.
Represents the state of an agent.
Represents the state of an agent in a system.
Represents a step in a process with an associated action and observation.
Represents the result of an agent's finish operation.
A wrapper for a
FunctionCallback.A class that serves as a builder for creating instances of
AgentFunctionCallbackWrapper.Represents the outcome of an agent's action.
Service class that uses the
ChatClient and
the ToolService to execute an LLM request.Represents the state of an agent with a map of data.
A factory interface for creating instances of
AgentState.This class is responsible for serializing and deserializing the state of an agent executor.
The AiMessageSerializer class implements the Serializer interface for the AiMessage type.
Class to grade answers based on whether they address a given question.
Represents the arguments for a structured prompt, encapsulating both a user's question and an LLM-generated response.
Binary score to assess answer addresses question.
Deprecated, for removal: This API element is subject to removal in a future version.
Deprecated, for removal: This API element is subject to removal in a future version.
AppenderChannel is a
Channel implementation that
is used to accumulate a list of values.A functional interface that is used to remove elements from a list.
Represents an asynchronous edge action that operates on an agent state and returns a new route.
Represents an asynchronous node action that operates on an agent state and returns state update.
Represents an asynchronous action that can be executed with a configuration.
The CallAgent class implements the NodeAction interface for handling
actions related to an AgentExecutor's state.
A Channel is a mechanism used to maintain a state property.
The ChatMesssageSerializer class is responsible for serializing and deserializing
ChatMessage objects.
Represents a checkpoint of an agent state.
The ChromaStore class provides a singleton interface for interacting with the Chroma Embedding Store.
Utility class for creating collections.
Represents a compiled graph of nodes and edges.
Demonstrates the use of Spring Boot CLI to execute a task using an agent executor.
This class implements the `NodeAction` interface for diagram image description.
Represents a diagram which contains various elements such as participants, relations, and containers.
Represents a container with a name, children, and a description.
Represents an element in a structured format.
Represents a participant in an event.
Represents a relation between two entities with an optional description.
Represents the process for correcting diagrams from images using asynchronous node and edge actions.
Abstract class for diagram generation.
Class that represents a context with various properties and methods.
This class provides functionality to parse a JSON formatted string and convert it into a `Diagram.Element` object.
Represents an edge action that operates on an agent state and returns a result.
Class declaration for EvaluateResult, which implements the AsyncNodeAction interface for ImageToDiagram.State.
The EvaluateResult class is designed to evaluate and process results asynchronously,
specifically targeting the conversion of image data to diagram data using an AI chat model.
This is an example of a public class designed to eventually perform correction.
The ExecuteTools class implements the NodeAction interface for handling
actions related to executing tools within an agent's context.
A CheckpointSaver that stores Checkpoints in the filesystem.
Configuration class for various functions related to weather.
This class provides a service for generating answers to questions using natural language processing.
Interface for service implementation that provides capabilities to answer questions based on given context.
The graph representation in diagram-as-a-code format.
The supported types.
Exception thrown when there is an error during the execution of a graph runner.
Exception thrown when there is an error related to the state of a graph.
Base Implementation of
PlainTextStateSerializer using GSON library
.Provides functionality to grade the groundedness of an LLM generation with respect to a set of facts.
Represents a set of facts and an associated LLM generation.
Binary score for hallucination present in generation answer.
The `ImageLoader` class provides utility methods for loading and converting images to Base64 format.
Represents the functionality to convert images to diagrams.
Represents the state of an agent, specifically tailored for managing diagram-related data and processes.
Class for processing images to generate diagrams.
Represents an image that can be identified by a URL or encapsulated as data.
Represents an intermediate step in a process, encapsulating an action taken by an agent
and the corresponding observation made.
Base Implementation of
PlainTextStateSerializer using Jackson library.JSONStateSerializer is a class that extends JacksonStateSerializer for serializing and deserializing
the state of an AgentExecutor using JSON format.
Interface for a LangGraph Streaming Server.
Metadata for an argument in a request.
Servlet for initializing the graph in mermaid format.
Servlet for handling graph stream requests.
Initialization data for the graph.
Serializer for InitData objects.
Configuration for persistent session data.
Represents an entry in a thread with its outputs.
Represents a streaming server for LangGraph using Jetty.
Builder class for constructing LangGraphStreamingServerJetty instances.
LLMStreamingGenerator is a class that extends AsyncGenerator to handle streaming outputs
for a given type T and state that extends AgentState.
Builder class for constructing instances of LLMStreamingGenerator.
This class represents a MermaidGenerator that extends DiagramGenerator.
Represents the agent's state as a collection of messages
Represents a state graph with messages for generic type T.
Represents the output of a node in a graph.
The `PlantUMLAction` class provides utility methods for validating PlantUML code.
Represents an error that occurred during the PlantUML code processing.
This class implements a
Function to rewrite questions for better vectorstore retrieval.Router for user queries to the most relevant datasource.
Represents a record that implements the
AppenderChannel.RemoveIdentifier<T> interface.The RetrievalGrader class implements a function to assess the relevance of a retrieved document
to a user's question.
Represents a structure for holding the arguments needed to process a user's query.
A static class that represents a score in a binary format.
The ReviewResult class implements the AsyncNodeAction interface for processing ImageToDiagram.State objects.
RouteDiagramTranslation class implements AsyncEdgeAction interface for processing
ImageToDiagram.State and determining the type of diagram.
Represents the result of evaluating a route.
A final class representing configuration for a runnable task.
A builder pattern class for constructing
RunnableConfig objects.Main application class for the SpringAI Demo project.
Represents a state graph with nodes and edges.
The STDStateSerializer class is responsible for serializing the state of the AgentExecutor.
The SystemMessageSerializer class implements the Serializer interface for the SystemMessage type.
The ToolExecutionRequestSerializer class implements the Serializer interface
for the ToolExecutionRequest type.
This class is responsible for serializing and deserializing
instances of ToolExecutionResultMessage.
A node in the graph that executes a tool
Builder for
ToolNodeService class responsible for managing tools and their callbacks.
TranslateGenericDiagramToPlantUML class implementation.
The `TranslateSequenceDiagramToPlantUML` class implements the NodeAction<ImageToDiagram.State> interface.
The UserMessageSerializer class implements the NullableObjectSerializer interface for the UserMessage type.
Configuration properties for weather services.
Class representing the WeatherFunction which implements a
Function interface to retrieve weather data from an external API.
Record representing weather conditions described in text form.
Record representing current weather details as part of the weather response.
Record representing location information as part of the weather response.
Record representing the request object for WeatherFunction.
Record representing the response object returned by the WeatherFunction.
The `WebSearchTool` class provides a solution for performing web searches based on user queries.