The Spring AI [ChatClient](https://docs.spring.io/spring-ai/reference/1.1.1/api/chatclient.html) offers a fluent API for communicating with an AI model.
The fluent API provides methods for building the constituent parts of a prompt that gets passed to the AI model as input.
[Advisors](https://docs.spring.io/spring-ai/reference/1.1.1/api/advisors.html) are a key part of the fluent API that intercept, modify, and enhance AI-driven interactions.
The key benefits include encapsulating common Generative AI patterns, transforming data sent to and from Large Language Models (LLMs), and providing portability across various models and use cases.
Advisors process `ChatClientRequest` and `ChatClientResponse` objects.
The framework chains advisors by their `getOrder()` values (lower values execute first), with the final advisor calling the LLM.
Spring AI provides built-in advisors for [Conversation Memory](https://docs.spring.io/spring-ai/reference/1.1.1/api/chat-memory.html#_memory_in_chat_client), [Retrieval Augmented Generation (RAG)](https://docs.spring.io/spring-ai/reference/1.1.1/api/retrieval-augmented-generation.html#_advisors), Logging, and Guardrails. Developers can also create custom advisors.
Typical advisor structure:
```java theme={null}
public class MyAdvisor implements CallAdvisor {
// 1. Sets the advisor orders
public int getOrder() { return MY_ADVISOR_ORDER; }
// 2. Sets the advisor name
public String getName() { return MY_ADVISOR_NAME; }
public ChatClientResponse adviseCall(ChatClientRequest request, CallAdvisorChain chain) {
// 3. Pre-process the request (modify, validate, log, etc.)
request = preProcess(request);
// 4. Call the next advisor in the chain
ChatClientResponse response = chain.nextCall(request);
// 5. Post-process the response (modify, validate, log, etc.)
return postProcess(response);
}
}
```
## Recursive Advisors
Starting with version `1.1.0-M4`, Spring AI introduces [Recursive Advisors](https://docs.spring.io/spring-ai/reference/1.1.1/api/advisors-recursive.html), enabling looping through the advisor chain multiple times to support iterative workflows:
* **Tool calling loops**: Executing multiple tools in sequence, where each tool's output informs the next decision
* **Output validation**: Validating structured responses and retrying with feedback when validation fails
* **Retry logic**: Refining requests based on response quality or external criteria
* **Evaluation flows**: Evaluating and modifying responses before delivery
* **Agentic loops**: Building autonomous agents that plan, execute, and iterate on tasks by analyzing results and determining next actions until a goal is achieved
Traditional single-pass advisor patterns cannot adequately handle these scenarios.
Recursive advisors loop through the downstream advisor chain multiple times, repeatedly calling the LLM until a condition is met.
The `CallAdvisorChain.copy(CallAdvisor after)` method creates a sub-chain containing only downstream advisors, enabling controlled iteration while maintaining proper ordering and observability, and preventing re-execution of upstream advisors.
*The diagram illustrates how recursive advisors enable iterative processing by allowing the flow to loop back through the advisor chain multiple times. Unlike traditional single-pass execution, recursive advisors can revisit previous advisors based on response conditions, creating sophisticated iterative workflows between the client, advisors, and LLM.*
* Loops until no more tool calls are present
* Enables other advisors (such as Advisor ABC) to intercept and alter each tool call request and response
* Supports "return direct" functionality
* Disables the chat-model's internal tool execution