---

name: langchain4j-ai-services-patterns description: Build declarative AI Services with LangChain4j using interface-based patterns, annotations, memory management, tools integration, and advanced application patterns. Use when implementing type-safe AI-powered features with minimal boilerplate code in Java applications. category: ai-development tags: [langchain4j, ai-services, annotations, declarative, tools, memory, function-calling, llm, java] version: 1.1.0 allowed-tools: Read, Write, Bash

LangChain4j AI Services Patterns

This skill provides guidance for building declarative AI Services with LangChain4j using interface-based patterns, annotations for system and user messages, memory management, tools integration, and advanced AI application patterns that abstract away low-level LLM interactions.

When to Use

Use this skill when:

• Building declarative AI-powered interfaces with minimal boilerplate code
• Creating type-safe AI services with Java interfaces and annotations
• Implementing conversational AI systems with memory management
• Designing AI services that can call external tools and functions
• Building multi-agent systems with specialized AI components
• Creating AI services with different personas and behaviors
• Implementing RAG (Retrieval-Augmented Generation) patterns declaratively
• Building production AI applications with proper error handling and validation
• Creating AI services that return structured data types (enums, POJOs, lists)
• Implementing streaming AI responses with reactive patterns

Overview

LangChain4j AI Services allow you to define AI-powered functionality using plain Java interfaces with annotations, eliminating the need for manual prompt construction and response parsing. This pattern provides type-safe, declarative AI capabilities with minimal boilerplate code.

Quick Start

Basic AI Service Definition

interface Assistant {
    String chat(String userMessage);
}

// Create instance - LangChain4j generates implementation
Assistant assistant = AiServices.create(Assistant.class, chatModel);

// Use the service
String response = assistant.chat("Hello, how are you?");

System Message and Templates

interface CustomerSupportBot {
    @SystemMessage("You are a helpful customer support agent for TechCorp")
    String handleInquiry(String customerMessage);

    @UserMessage("Analyze sentiment: {{it}}")
    String analyzeSentiment(String feedback);
}

CustomerSupportBot bot = AiServices.create(CustomerSupportBot.class, chatModel);

Memory Management

interface MultiUserAssistant {
    String chat(@MemoryId String userId, String userMessage);
}

Assistant assistant = AiServices.builder(MultiUserAssistant.class)
    .chatModel(model)
    .chatMemoryProvider(userId -> MessageWindowChatMemory.withMaxMessages(10))
    .build();

Tool Integration

class Calculator {
    @Tool("Add two numbers") double add(double a, double b) { return a + b; }
}

interface MathGenius {
    String ask(String question);
}

MathGenius mathGenius = AiServices.builder(MathGenius.class)
    .chatModel(model)
    .tools(new Calculator())
    .build();

Examples

See examples.md for comprehensive practical examples including:

• Basic chat interfaces
• Stateful assistants with memory
• Multi-user scenarios
• Structured output extraction
• Tool calling and function execution
• Streaming responses
• Error handling
• RAG integration
• Production patterns

API Reference

Complete API documentation, annotations, interfaces, and configuration patterns are available in references.md.

Best Practices

1. Use type-safe interfaces instead of string-based prompts
2. Implement proper memory management with appropriate limits
3. Design clear tool descriptions with parameter documentation
4. Handle errors gracefully with custom error handlers
5. Use structured output for predictable responses
6. Implement validation for user inputs
7. Monitor performance for production deployments

Dependencies

<!-- Maven -->
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j</artifactId>
    <version>1.8.0</version>
</dependency>
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-open-ai</artifactId>
    <version>1.8.0</version>
</dependency>

// Gradle
implementation 'dev.langchain4j:langchain4j:1.8.0'
implementation 'dev.langchain4j:langchain4j-open-ai:1.8.0'

References

• LangChain4j Documentation
• LangChain4j AI Services - API References
• LangChain4j AI Services - Practical Examples