# coder-langchain4j

**Repository Path**: monkeyofdk/coder-langchain4j

## Basic Information

- **Project Name**: coder-langchain4j
- **Description**: No description available
- **Primary Language**: Java
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2025-11-08
- **Last Updated**: 2025-11-08

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# LangChain4j

# 调用方式

## yaml配置

```yaml
langchain4j:
  open-ai:
    chat-model:
      api-key: "sk-48128a6570774516ba10b5d85a9a12f6" # api key
      base-url: "https://dashscope.aliyuncs.com/compatible-mode/v1" # 模型地址
      model-name: "qwen-plus" # 模型名称
```

## 方式一

直接使用openAiChatModel\
`test`

```java

@SpringBootTest
public class LangChain4JServiceTest {
    @Resource
    private OpenAiChatModel openAiChatModel;

    @Test
    void chat() {
        String res = openAiChatModel.chat("你是谁？");
        System.out.println(res);
    }
}
```

## 方式二

利用AiService \
`service`

```java

@AiService(
        wiringMode = AiServiceWiringMode.EXPLICIT,
        chatModel = "openAiChatModel",
        streamingChatModel = "openAiStreamingChatModel"
)
public interface ChatService {
    String chat(String message);

    Flux<String> chatStream(String message);
}
```

`test`

```java

@SpringBootTest
class ChatServiceTest {
    @Resource
    private ChatService chatService;

    @Test
    void chat() {
        String res = chatService.chat("你是谁？");
        System.out.println(res);
    }

    @Test
    void chatStream() {
        Flux<String> res = chatService.chatStream("你是谁？");
        res.doOnNext(System.out::println).subscribe();
    }
}
```

`controller`

```java

@RestController
@RequestMapping("/chat")
public class ChatController {
    @Resource
    private ChatService chatService;

    @GetMapping(value = "/streamSend", produces = "text/html;charset=UTF-8")
    public Flux<String> streamSend(@RequestParam("message") String message) {
        return chatService.chatStream(message);
    }
}
```

# 添加系统提示词

```java

@AiService(
        wiringMode = AiServiceWiringMode.EXPLICIT,
        chatModel = "openAiChatModel",
        streamingChatModel = "openAiStreamingChatModel"
)
public interface ChatService {
    String chat(String message);

    @SystemMessage(fromResource = "system_prompt.txt")
    Flux<String> chatStream(String message);
}
```

# 会话记忆

`configuration`

```java

@Configuration
public class ChatMemoryConfig {

    @Bean
    public ChatMemory windowChatMemory() {
        return MessageWindowChatMemory.builder().maxMessages(20).build();
    }

    @Bean
    public ChatMemoryProvider chatMemoryProvider() {
        return id -> MessageWindowChatMemory.builder().id(id).maxMessages(20).build();
    }
}
```

# 会话持久化

基于redis, 实现ChatMemoryStore接口，完成存储逻辑

```java
@Component
public class RedisChatMemoryStore implements ChatMemoryStore {
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public List<ChatMessage> getMessages(Object id) {
        String messages = stringRedisTemplate.opsForValue().get(id);
        return ChatMessageDeserializer.messagesFromJson(messages);
    }

    @Override
    public void updateMessages(Object o, List<ChatMessage> list) {
        String messages = ChatMessageSerializer.messagesToJson(list);
        stringRedisTemplate.opsForValue().set(o.toString(), messages, 60, TimeUnit.MINUTES);
    }

    @Override
    public void deleteMessages(Object o) {
        stringRedisTemplate.delete(o.toString());
    }
}
```
# Rag
`configuration`
```java
@Configuration
public class RagConfig {
    @Resource
    private EmbeddingModel embeddingModel;
    @Bean
    public EmbeddingStore<TextSegment> memoryEmbeddingStore() {
        // 加载文档
        List<Document> documents = ClassPathDocumentLoader.loadDocuments("static");
        // 构建基于内存的向量存储
        EmbeddingStore<TextSegment> embeddingStore = new InMemoryEmbeddingStore<>();
        EmbeddingStoreIngestor embeddingStoreIngestor = EmbeddingStoreIngestor.builder()
                .embeddingStore(embeddingStore)
//                .embeddingModel(embeddingModel)
                .build();
        embeddingStoreIngestor.ingest(documents);
        return embeddingStore;
    }

    @Bean
    public ContentRetriever contentRetriever(EmbeddingStore memoryEmbeddingStore) {
        // 检索
        return EmbeddingStoreContentRetriever.builder()
                .embeddingStore(memoryEmbeddingStore)
                .minScore(0.7)
                .maxResults(3)
                .build();
    }
}
```