langchain4j-ai-services-patterns

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.

⭐38stars🔀2forks📁View on GitHub🕐Updated Dec 27, 2025⬇️3downloads

When & Why to Use This Skill

This Claude skill provides a comprehensive framework for building declarative, type-safe AI services using LangChain4j in Java. It focuses on abstracting complex LLM interactions through interface-based patterns, annotations, and automated memory management, allowing developers to integrate advanced AI capabilities into enterprise Java applications with minimal boilerplate and maximum maintainability.

Use Cases

  • 1. Type-Safe AI Integration: Implementing AI-powered features in Java applications using standard interfaces and annotations to ensure compile-time safety and clean code architecture.
  • 2. Conversational Agent Development: Building sophisticated chatbots and virtual assistants that require persistent memory management and context handling across multiple user sessions.
  • 3. Automated Tool & Function Calling: Designing AI services that can autonomously interact with external systems, APIs, and local Java methods to perform real-world tasks.
  • 4. Structured Data Extraction: Automatically transforming unstructured LLM responses into predictable Java objects (POJOs), enums, or lists for seamless downstream processing.
  • 5. Declarative RAG Implementation: Constructing Retrieval-Augmented Generation systems by defining high-level patterns for data retrieval and context injection without manual prompt engineering.
namelangchain4j-ai-services-patterns
descriptionBuild 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.
categoryai-development
tags[langchain4j, ai-services, annotations, declarative, tools, memory, function-calling, llm, java]
version1.1.0
allowed-toolsRead, 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