CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/maven-org-springframework-ai--spring-ai-client-chat

Spring AI Chat Client provides a fluent API for building AI-powered applications with LLMs, supporting advisors, streaming, structured outputs, and conversation memory

Overview
Eval results
Files

Spring AI Chat Client

Fluent API for building AI-powered applications with Large Language Models. Provides chainable interface similar to Spring's WebClient with support for advisors, streaming, structured outputs, and conversation memory.

Installation

<dependency>
  <groupId>org.springframework.ai</groupId>
  <artifactId>spring-ai-client-chat</artifactId>
  <version>1.1.2</version>
</dependency>

Repository Configuration (required - not in Maven Central):

<repositories>
  <repository>
    <id>spring-milestones</id>
    <url>https://repo.spring.io/milestone</url>
  </repository>
</repositories>

Quick Start

import org.springframework.ai.chat.client.ChatClient;

// Create client
ChatClient client = ChatClient.create(chatModel);

// Simple request
String response = client.prompt("What is Spring?").call().content();

// Structured output
record Answer(String topic, String summary) {}
Answer answer = client.prompt("Explain Spring").call().entity(Answer.class);

// Streaming
Flux<String> stream = client.prompt("Tell a story").stream().content();

Core Concepts

ChatClient

Main entry point for AI interactions. Create once, reuse for all requests.

// Factory methods
static ChatClient create(ChatModel chatModel);
static ChatClient.Builder builder(ChatModel chatModel);

// Request methods
ChatClientRequestSpec prompt();
ChatClientRequestSpec prompt(String text);

Request Configuration

Fluent API for building requests with messages, options, tools, and advisors.

interface ChatClientRequestSpec {
    ChatClientRequestSpec user(String text);
    ChatClientRequestSpec system(String text);
    ChatClientRequestSpec advisors(Advisor... advisors);
    ChatClientRequestSpec tools(Object... toolObjects);
    ChatClientRequestSpec options(ChatOptions options);
    CallResponseSpec call();
    StreamResponseSpec stream();
}

Response Handling

Access responses as text, typed entities, or full ChatResponse objects.

interface CallResponseSpec {
    String content();
    ChatResponse chatResponse();
    <T> T entity(Class<T> type);
    <T> ResponseEntity<ChatResponse, T> responseEntity(Class<T> type);
}

interface StreamResponseSpec {
    Flux<String> content();
    Flux<ChatResponse> chatResponse();
}

Advisors

Interceptors that modify requests/responses in a chain-of-responsibility pattern.

interface Advisor extends Ordered {
    String getName();
    int getOrder();
}

interface CallAdvisor extends Advisor {
    ChatClientResponse adviseCall(ChatClientRequest request, CallAdvisorChain chain);
}

interface StreamAdvisor extends Advisor {
    Flux<ChatClientResponse> adviseStream(ChatClientRequest request, StreamAdvisorChain chain);
}

Quick Reference

Built-in Advisors

AdvisorPurposeOrder
SafeGuardAdvisorBlock sensitive content100
MessageChatMemoryAdvisorConversation history (messages)1001
PromptChatMemoryAdvisorConversation history (text)1001
ToolCallAdvisorFunction calling loop3000
StructuredOutputValidationAdvisorValidate JSON output5000
SimpleLoggerAdvisorRequest/response loggingLOWEST

Common Patterns

Configured Client:

ChatClient client = ChatClient.builder(chatModel)
    .defaultSystem("You are a helpful assistant")
    .defaultAdvisors(memoryAdvisor, loggerAdvisor)
    .defaultOptions(options)
    .build();

Streaming with Memory:

Flux<String> stream = client
    .prompt("Continue our conversation")
    .advisors(spec -> spec.param("conversationId", "user-123"))
    .stream()
    .content();

Tool Calling:

WeatherResponse weather = client
    .prompt("What's the weather in Paris?")
    .toolCallbacks(weatherTool)
    .advisors(ToolCallAdvisor.builder().build())
    .call()
    .entity(WeatherResponse.class);

Structured Output with Validation:

Person person = client
    .prompt("Generate person profile")
    .advisors(StructuredOutputValidationAdvisor.builder()
        .outputType(Person.class)
        .maxRepeatAttempts(3)
        .build())
    .call()
    .entity(Person.class);

Architecture

ChatClient (thread-safe, reusable)
    ↓
Request Configuration (fluent API)
    ↓
Advisor Chain (ordered interceptors)
    ↓
ChatModel (AI provider)
    ↓
Response Processing (text/entity/stream)

Key Components:

  1. ChatClient: Main API, create once and reuse
  2. Advisors: Interceptors for cross-cutting concerns (ordered execution)
  3. Request/Response: Immutable data structures with context maps
  4. Observability: Micrometer integration for metrics/tracing
  5. Evaluation: Built-in quality assessment

Documentation

Guides

  • Quick Start Guide - Step-by-step getting started
  • Building Requests - Request configuration patterns
  • Working with Advisors - Using and creating advisors
  • Conversation Memory - Managing chat history
  • Tool Calling - Function calling with AI

Examples

Reference

Key Features

Fluent API

Chainable interface for intuitive request building:

client.prompt().system("...").user("...").options(...).call().content()

Advisor Pattern

Extensible interceptor chain for:

  • Conversation memory
  • Logging and monitoring
  • Content filtering
  • Validation and retry
  • Tool calling orchestration

Streaming Support

Reactive streaming with Project Reactor:

Flux<String> stream = client.prompt("...").stream().content();

Structured Outputs

Type-safe entity conversion:

MyType result = client.prompt("...").call().entity(MyType.class);

Observability

Built-in Micrometer integration for production monitoring.

Thread Safety

ChatClient instances are thread-safe and should be reused across requests.

Common Use Cases

  • Chatbots: Multi-turn conversations with memory
  • Content Generation: Structured output with validation
  • RAG Applications: Tool calling for data retrieval
  • Streaming UIs: Real-time response display
  • Production Services: Observability and error handling

External Dependencies

This tile documents the Chat Client API. Related types from other packages:

  • ChatModel - AI model interface (from org.springframework.ai.chat.model)
  • ChatOptions - Model configuration (from org.springframework.ai.chat.options)
  • Message types - UserMessage, SystemMessage, etc.
  • ToolCallback - Function calling (from org.springframework.ai.tool)
  • ObservationRegistry - Micrometer observability

See respective Spring AI packages for complete documentation of these types.

Install with Tessl CLI

npx tessl i tessl/maven-org-springframework-ai--spring-ai-client-chat
Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/org.springframework.ai/spring-ai-client-chat@1.1.x