LangChain4j案例

本文目录导读：

1. 基础对话案例
2. RAG（检索增强生成）案例
3. 多轮对话案例
4. 工具调用案例（Function Calling）
5. 流式输出案例
6. 文档问答案例
7. Spring Boot集成案例
8. 依赖配置

我来为您提供几个LangChain4j的实用案例,帮助您快速上手。

基础对话案例

import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.service.AiServices;
import dev.langchain4j.service.UserMessage;
public class BasicChatExample {
    // 定义AI服务接口
    interface Assistant {
        @UserMessage("你是一个友好的助手，请回答用户的问题：{{userMessage}}")
        String chat(String userMessage);
    }
    public static void main(String[] args) {
        // 创建模型
        OpenAiChatModel model = OpenAiChatModel.builder()
                .apiKey("your-api-key")
                .modelName("gpt-3.5-turbo")
                .temperature(0.7)
                .build();
        // 创建AI服务
        Assistant assistant = AiServices.create(Assistant.class, model);
        // 使用
        String response = assistant.chat("什么是Java？");
        System.out.println(response);
    }
}

RAG（检索增强生成）案例

import dev.langchain4j.data.document.Document;
import dev.langchain4j.data.embedding.Embedding;
import dev.langchain4j.data.segment.TextSegment;
import dev.langchain4j.model.embedding.EmbeddingModel;
import dev.langchain4j.store.embedding.EmbeddingStore;
import dev.langchain4j.store.embedding.inmemory.InMemoryEmbeddingStore;
import dev.langchain4j.rag.content.retriever.ContentRetriever;
import dev.langchain4j.rag.content.retriever.EmbeddingStoreContentRetriever;
public class RAGExample {
    public static void main(String[] args) {
        // 1. 准备文档
        Document document = Document.from(
            "LangChain4j是一个Java版本的LangChain框架，" +
            "用于构建基于大语言模型的应用程序。"
        );
        // 2. 创建嵌入模型
        EmbeddingModel embeddingModel = new BgeSmallEnEmbeddingModel();
        // 3. 创建向量存储
        EmbeddingStore<TextSegment> embeddingStore = new InMemoryEmbeddingStore<>();
        // 4. 将文档转换为向量并存储
        TextSegment segment = TextSegment.from(document.text());
        Embedding embedding = embeddingModel.embed(segment.text()).content();
        embeddingStore.add(embedding, segment);
        // 5. 创建检索器
        ContentRetriever retriever = EmbeddingStoreContentRetriever.builder()
                .embeddingStore(embeddingStore)
                .embeddingModel(embeddingModel)
                .maxResults(3)
                .build();
        // 6. 创建带RAG的AI服务
        interface RAGAssistant {
            @UserMessage("基于以下上下文回答问题：\n{{context}}\n\n问题：{{question}}")
            String answer(String question);
        }
        RAGAssistant assistant = AiServices.builder(RAGAssistant.class)
                .contentRetriever(retriever)
                .build();
        // 7. 使用
        String answer = assistant.answer("LangChain4j是什么？");
        System.out.println(answer);
    }
}

多轮对话案例

import dev.langchain4j.memory.chat.MessageWindowChatMemory;
import dev.langchain4j.service.MemoryId;
public class MultiTurnConversationExample {
    interface ChatBot {
        @MemoryId
        String chat(@MemoryId String user, @UserMessage String message);
    }
    public static void main(String[] args) {
        OpenAiChatModel model = OpenAiChatModel.builder()
                .apiKey("your-api-key")
                .modelName("gpt-3.5-turbo")
                .build();
        ChatBot chatBot = AiServices.builder(ChatBot.class)
                .chatLanguageModel(model)
                .chatMemory(MessageWindowChatMemory.withMaxMessages(10))
                .build();
        // 多轮对话
        System.out.println(chatBot.chat("user1", "我的名字是张三"));
        System.out.println(chatBot.chat("user1", "你还记得我叫什么吗？"));
        // 不同用户
        System.out.println(chatBot.chat("user2", "我叫李四"));
        System.out.println(chatBot.chat("user2", "我叫什么？"));
    }
}

工具调用案例（Function Calling）

import dev.langchain4j.agent.tool.Tool;
import dev.langchain4j.agent.tool.ToolSpecification;
public class ToolCallingExample {
    // 定义工具
    static class Calculator {
        @Tool("计算两个数的和")
        public int add(int a, int b) {
            return a + b;
        }
        @Tool("获取当前时间")
        public String getCurrentTime() {
            return LocalDateTime.now().toString();
        }
    }
    public static void main(String[] args) {
        OpenAiChatModel model = OpenAiChatModel.builder()
                .apiKey("your-api-key")
                .modelName("gpt-3.5-turbo")
                .build();
        // 创建带工具的AI服务
        interface Assistant {
            String chat(String message);
        }
        Assistant assistant = AiServices.builder(Assistant.class)
                .chatLanguageModel(model)
                .tools(new Calculator())
                .build();
        // 使用工具
        System.out.println(assistant.chat("请计算123 + 456 = ?"));
        System.out.println(assistant.chat("现在几点了？"));
    }
}

流式输出案例

import dev.langchain4j.model.StreamingResponseHandler;
import dev.langchain4j.model.output.Response;
public class StreamingExample {
    public static void main(String[] args) {
        OpenAiStreamingChatModel model = OpenAiStreamingChatModel.builder()
                .apiKey("your-api-key")
                .modelName("gpt-3.5-turbo")
                .build();
        // 创建流式AI服务
        interface StreamingAssistant {
            @UserMessage("请详细解释：{{topic}}")
            TokenStream explain(String topic);
        }
        StreamingAssistant assistant = AiServices.create(StreamingAssistant.class, model);
        TokenStream stream = assistant.explain("量子计算");
        stream.onNext(token -> System.out.print(token))
              .onComplete(response -> System.out.println("\n\n完成!"))
              .onError(error -> System.err.println("错误: " + error.getMessage()))
              .start();
    }
}

文档问答案例

import dev.langchain4j.data.document.loader.FileSystemDocumentLoader;
import dev.langchain4j.data.document.parser.TextDocumentParser;
public class DocumentQAExample {
    public static void main(String[] args) {
        // 1. 加载文档
        Document document = FileSystemDocumentLoader.loadDocument(
            "path/to/document.txt",
            new TextDocumentParser()
        );
        // 2. 分割文档
        DocumentSplitter splitter = DocumentSplitters.recursive(500, 50);
        List<TextSegment> segments = splitter.split(document);
        // 3. 创建嵌入并存储
        EmbeddingModel embeddingModel = new BgeSmallEnEmbeddingModel();
        EmbeddingStore<TextSegment> embeddingStore = new InMemoryEmbeddingStore<>();
        for (TextSegment segment : segments) {
            Embedding embedding = embeddingModel.embed(segment.text()).content();
            embeddingStore.add(embedding, segment);
        }
        // 4. 问答
        interface DocumentQA {
            String answer(String question);
        }
        DocumentQA qa = AiServices.builder(DocumentQA.class)
                .contentRetriever(EmbeddingStoreContentRetriever.builder()
                    .embeddingStore(embeddingStore)
                    .embeddingModel(embeddingModel)
                    .build())
                .build();
        System.out.println(qa.answer("文档的主要内容是什么？"));
    }
}

Spring Boot集成案例

@SpringBootApplication
public class LangChain4jSpringExample {
    public static void main(String[] args) {
        SpringApplication.run(LangChain4jSpringExample.class, args);
    }
}
// 配置类
@Configuration
class LangChain4jConfig {
    @Bean
    public OpenAiChatModel openAiChatModel() {
        return OpenAiChatModel.builder()
                .apiKey("${openai.api-key}")
                .modelName("gpt-3.5-turbo")
                .build();
    }
}
// 服务类
@Service
class ChatService {
    private final Assistant assistant;
    @Autowired
    public ChatService(OpenAiChatModel model) {
        this.assistant = AiServices.create(Assistant.class, model);
    }
    public String chat(String message) {
        return assistant.chat(message);
    }
    interface Assistant {
        String chat(String message);
    }
}
// Controller
@RestController
class ChatController {
    @Autowired
    private ChatService chatService;
    @PostMapping("/chat")
    public String chat(@RequestBody String message) {
        return chatService.chat(message);
    }
}

依赖配置

<dependencies>
    <dependency>
        <groupId>dev.langchain4j</groupId>
        <artifactId>langchain4j</artifactId>
        <version>0.33.0</version>
    </dependency>
    <dependency>
        <groupId>dev.langchain4j</groupId>
        <artifactId>langchain4j-open-ai</artifactId>
        <version>0.33.0</version>
    </dependency>
    <!-- 嵌入模型 -->
    <dependency>
        <groupId>dev.langchain4j</groupId>
        <artifactId>langchain4j-embeddings-bge-small-en</artifactId>
        <version>0.33.0</version>
    </dependency>
</dependencies>

这些案例涵盖了LangChain4j的主要功能特性,从基础对话到高级的RAG和工具调用，您可以根据实际需求进行调整和扩展。