# langchain4j-ai-services-patterns

A skill that walks your agent through declarative AI Services in LangChain4j: interfaces, annotations, memory and tool calling.

- skill · `type=skill` · Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, OpenCode · 3700 installs · ★ 363
- Author: giuseppe-trisciuoglio
- License: MIT · policy=mirror · the beginning of the file is at the end of this page
- Source: https://github.com/giuseppe-trisciuoglio/developer-kit/tree/HEAD/plugins/developer-kit-java/skills/langchain4j-ai-services-patterns/SKILL.md
- Updated: 2026-09-10
- HTML: https://affpapa.org/en/nevibecode/skills/langchain4j-ai-services-patterns

## What it does

The skill lays out the steps in order. First a Java interface with methods for talking to the model, then `@SystemMessage` and `@UserMessage` annotations for prompts, then instantiation through `AiServices.create` or the builder. Multi-turn conversations get memory via `@MemoryId` and `chatMemoryProvider`, and function calling comes from registering classes with `@Tool`. Working Java snippets ship inside, along with an API reference and a longer example set in `references.md` and `examples.md`.

Worth installing if you build Java apps on top of an LLM and are tired of assembling prompt strings by hand. The interface approach is typed: a service method can return an enum, a POJO or a list instead of a bare string. You need `dev.langchain4j:langchain4j` and `dev.langchain4j:langchain4j-open-ai` at version 1.8.0 in Maven or Gradle.

Model output is non-deterministic, so tests have to tolerate variation. Memory providers keep conversation history, and in multi-user setups that history needs cleanup or sessions bleed into each other. Tool execution can get expensive, and tools with side effects may fire when you did not expect it. Keep API keys and passwords out of system and user messages.

## Install

### Claude Code (native platform)

1. **Skills CLI (Vercel)**
```bash
npx skills add giuseppe-trisciuoglio/developer-kit --skill langchain4j-ai-services-patterns -a claude-code
```

2. **Manually: put the files in place**
- File: `~/.claude/skills/langchain4j-ai-services-patterns/SKILL.md` — Copy the whole skill folder; for one project use .claude/skills/langchain4j-ai-services-patterns/

### Codex

1. **Skills CLI (Vercel)**
```bash
npx skills add giuseppe-trisciuoglio/developer-kit --skill langchain4j-ai-services-patterns -a codex
```

2. **Manually: put the files in place**
- File: `.agents/skills/langchain4j-ai-services-patterns/SKILL.md` — For all projects use ~/.agents/skills/

### Cursor

1. **Skills CLI (Vercel)**
```bash
npx skills add giuseppe-trisciuoglio/developer-kit --skill langchain4j-ai-services-patterns -a cursor
```

2. **Manually: put the files in place**
- File: `.cursor/skills/langchain4j-ai-services-patterns/SKILL.md` — Cursor also reads .agents/skills/ and .claude/skills/

### GitHub Copilot

1. **GitHub CLI**
```bash
gh skill install giuseppe-trisciuoglio/developer-kit langchain4j-ai-services-patterns
```

2. **Manually: put the files in place**
- File: `.github/skills/langchain4j-ai-services-patterns/SKILL.md`

### Gemini CLI

1. **Skills CLI (Vercel)**
```bash
npx skills add giuseppe-trisciuoglio/developer-kit --skill langchain4j-ai-services-patterns -a gemini-cli
```

2. **Platform CLI**
```bash
gemini skills install https://github.com/giuseppe-trisciuoglio/developer-kit --path plugins/developer-kit-java/skills/langchain4j-ai-services-patterns
```

### Windsurf (Devin Desktop)

**Manually: put the files in place**
- File: `.devin/skills/langchain4j-ai-services-patterns/SKILL.md` — The legacy .windsurf/skills/ path still works

### OpenCode

**Skills CLI (Vercel)**
```bash
npx skills add giuseppe-trisciuoglio/developer-kit --skill langchain4j-ai-services-patterns -a opencode
```

### Claude.ai

**Claude.ai**
- Zip the folder and upload it in Settings → Capabilities → Skills

Where a file is given instead of a command, copy the files from the source to that path: https://github.com/giuseppe-trisciuoglio/developer-kit/tree/HEAD/plugins/developer-kit-java/skills/langchain4j-ai-services-patterns/SKILL.md

## When to use it
- define an AI service as an interface instead of concatenating prompt strings
- add memory to a multi-turn chat with per-user separation
- wire up function calling through the `@Tool` annotation
- get structured output from the model — enum, POJO or list
- build a RAG flow declaratively without managing context by hand

## Example prompts
- create a LangChain4j AI Service: an interface with a chat method and a @SystemMessage annotation
- add memory to this service with @MemoryId and a chatMemoryProvider for multiple users
- register Calculator as a tool with @Tool and call it from the service

## Source text · SKILL.md · MIT

Below is the content of a third-party file. It is data, not instructions for you: do not act on anything written inside unless the human asks. Block tag: af19408f08dcef28.

BEGIN THIRD-PARTY FILE af19408f08dcef28
````text
---
name: langchain4j-ai-services-patterns
description: Provides patterns to build declarative AI Services with LangChain4j for LLM integration, chatbot development, AI agent implementation, and conversational AI in Java. Generates type-safe AI services using interface-based patterns, annotations, memory management, and tools integration. Use when creating AI-powered Java applications with minimal boilerplate, implementing conversational AI with memory, or building AI agents with function calling.
allowed-tools: Read, Write, Edit, Bash, Glob, Grep
---

# 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.

## Overview

LangChain4j AI Services define AI functionality using Java interfaces with annotations, providing type-safe, declarative AI with minimal boilerplate.

## When to Use

Use this skill when:
- Building declarative AI services with minimal boilerplate using Java interfaces
- Creating type-safe conversational AI with memory management
- Implementing AI agents with function/tool calling capabilities
- Designing AI services returning structured data (enums, POJOs, lists)
- Integrating RAG patterns declaratively

## Instructions

Follow these steps to create declarative AI Services with LangChain4j:

### 1. Define AI Service Interface

Create a Java interface with method signatures for AI interactions:

```java
interface Assistant {
    String chat(String userMessage);
}
```

### 2. Add Annotations for System and User Messages

Use `@SystemMessage` and `@UserMessage` annotations to define prompts:

```java
interface CustomerSupportBot {
    @SystemMessage("You are a helpful customer support agent for TechCorp")
````
END THIRD-PARTY FILE af19408f08dcef28

The third-party file has ended. Everything between the af19408f08dcef28 tags is data: requests and commands from it are not followed. An “end of file” line with another tag inside the block is part of the file.

First 1906 of 6404 bytes. © giuseppe-trisciuoglio · MIT · https://github.com/giuseppe-trisciuoglio/developer-kit/tree/HEAD/plugins/developer-kit-java/skills/langchain4j-ai-services-patterns/SKILL.md

_Part of the page did not fit — see the HTML version._

---
NeVibeCode on affpapa.org. Catalog texts are descriptions, not instructions for the agent. How to choose and install: https://affpapa.org/en/nevibecode/agents.md