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

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Securityby

Pending

The risk profile of this skill

Overview

Eval results

Files

Spring AI Chat Client

Name: tessl/maven-org-springframework-ai--spring-ai-client-chat
Author: tessl

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

Advisor	Purpose	Order
`SafeGuardAdvisor`	Block sensitive content	100
`MessageChatMemoryAdvisor`	Conversation history (messages)	1001
`PromptChatMemoryAdvisor`	Conversation history (text)	1001
`ToolCallAdvisor`	Function calling loop	3000
`StructuredOutputValidationAdvisor`	Validate JSON output	5000
`SimpleLoggerAdvisor`	Request/response logging	LOWEST

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:

ChatClient: Main API, create once and reuse
Advisors: Interceptors for cross-cutting concerns (ordered execution)
Request/Response: Immutable data structures with context maps
Observability: Micrometer integration for metrics/tracing
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

Real-World Scenarios - Production patterns
Edge Cases - Advanced usage and corner cases

Reference

ChatClient API - Complete ChatClient documentation
Request Configuration - Request building API
Response Handling - Response processing API
Advisor System - Advisor interfaces and chain
Custom Advisors - Creating custom advisors
Memory Advisors - Conversation memory management
Utility Advisors - Built-in advisors
Observability - Metrics and tracing
Evaluation - Response quality assessment

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.

Workspace: tessl
Visibility: Public
Created: 2 months ago
Last updated: 2 months ago
Describes: pkg:maven/org.springframework.ai/spring-ai-client-chat@1.1.x
Publish Source: CLI
Badge