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

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.

Install with Tessl CLI

npx tessl i tessl/maven-org-springframework-ai--spring-ai-client-chat@1.1.0

docs

examples

guides

reference

index.md

tile.json