麻瓜教程

Appearance

聊天机器人 ​

基础聊天机器人 ​

基本实现 ​

java
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.model.chat.ChatLanguageModel;

public class BasicChatBot {
    public static void main(String[] args) {
        // 创建模型
        ChatLanguageModel model = OpenAiChatModel.builder()
                .apiKey(System.getenv("OPENAI_API_KEY"))
                .modelName("gpt-3.5-turbo")
                .build();

        // 简单聊天循环
        Scanner scanner = new Scanner(System.in);
        System.out.println("聊天机器人已启动，输入 'exit' 退出");
        
        while (true) {
            System.out.print("你: ");
            String input = scanner.nextLine();
            
            if (input.equalsIgnoreCase("exit")) {
                System.out.println("聊天结束");
                break;
            }
            
            // 生成响应
            String response = model.generate(input);
            System.out.println("机器人: " + response);
        }
        
        scanner.close();
    }
}

带系统提示词的聊天机器人 ​

java
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.data.message.SystemMessage;
import dev.langchain4j.data.message.UserMessage;
import dev.langchain4j.data.message.AiMessage;
import java.util.ArrayList;
import java.util.List;

public class SystemPromptChatBot {
    public static void main(String[] args) {
        // 创建模型
        ChatLanguageModel model = OpenAiChatModel.builder()
                .apiKey(System.getenv("OPENAI_API_KEY"))
                .modelName("gpt-3.5-turbo")
                .build();

        // 系统提示词
        SystemMessage systemMessage = SystemMessage.from(
                "你是一个友好的聊天机器人，擅长回答技术问题，特别是关于 Java 和 LangChain4J 的问题。"
        );

        // 消息历史
        List<UserMessage> userMessages = new ArrayList<>();
        List<AiMessage> aiMessages = new ArrayList<>();

        // 聊天循环
        Scanner scanner = new Scanner(System.in);
        System.out.println("技术聊天机器人已启动，输入 'exit' 退出");
        
        while (true) {
            System.out.print("你: ");
            String input = scanner.nextLine();
            
            if (input.equalsIgnoreCase("exit")) {
                System.out.println("聊天结束");
                break;
            }
            
            // 添加用户消息
            UserMessage userMessage = UserMessage.from(input);
            userMessages.add(userMessage);
            
            // 构建消息列表
            List<Message> messages = new ArrayList<>();
            messages.add(systemMessage);
            
            // 添加最近的对话历史（保持上下文）
            int startIndex = Math.max(0, userMessages.size() - 3);
            for (int i = startIndex; i < userMessages.size(); i++) {
                messages.add(userMessages.get(i));
                if (i < aiMessages.size()) {
                    messages.add(aiMessages.get(i));
                }
            }
            
            // 生成响应
            AiMessage response = model.generate(messages);
            aiMessages.add(response);
            
            System.out.println("机器人: " + response.text());
        }
        
        scanner.close();
    }
}

上下文感知聊天 ​

带记忆的聊天机器人 ​

java
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.memory.chat.MessageWindowChatMemory;
import dev.langchain4j.model.chat.ChatLanguageModelWithMemory;

public class ContextAwareChatBot {
    public static void main(String[] args) {
        // 创建模型
        ChatLanguageModel model = OpenAiChatModel.builder()
                .apiKey(System.getenv("OPENAI_API_KEY"))
                .modelName("gpt-3.5-turbo")
                .build();

        // 创建记忆
        MessageWindowChatMemory memory = MessageWindowChatMemory.builder()
                .maxMessages(10) // 保持最近的 10 条消息
                .build();

        // 创建带记忆的模型
        ChatLanguageModelWithMemory modelWithMemory = ChatLanguageModelWithMemory.builder()
                .chatLanguageModel(model)
                .chatMemory(memory)
                .build();

        // 聊天循环
        Scanner scanner = new Scanner(System.in);
        System.out.println("上下文感知聊天机器人已启动，输入 'exit' 退出");
        
        while (true) {
            System.out.print("你: ");
            String input = scanner.nextLine();
            
            if (input.equalsIgnoreCase("exit")) {
                System.out.println("聊天结束");
                break;
            }
            
            // 生成响应（模型会记住之前的对话）
            String response = modelWithMemory.generate(input);
            System.out.println("机器人: " + response);
        }
        
        scanner.close();
    }
}

带持久化记忆的聊天机器人 ​

java
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.memory.chat.PersistentChatMemory;
import dev.langchain4j.model.chat.ChatLanguageModelWithMemory;
import dev.langchain4j.store.memory.SimpleMemoryStore;

public class PersistentChatBot {
    public static void main(String[] args) {
        // 创建模型
        ChatLanguageModel model = OpenAiChatModel.builder()
                .apiKey(System.getenv("OPENAI_API_KEY"))
                .modelName("gpt-3.5-turbo")
                .build();

        // 创建持久化记忆
        SimpleMemoryStore memoryStore = new SimpleMemoryStore();
        PersistentChatMemory memory = PersistentChatMemory.builder()
                .id("user-123") // 用户 ID
                .storage(memoryStore)
                .build();

        // 创建带记忆的模型
        ChatLanguageModelWithMemory modelWithMemory = ChatLanguageModelWithMemory.builder()
                .chatLanguageModel(model)
                .chatMemory(memory)
                .build();

        // 聊天循环
        Scanner scanner = new Scanner(System.in);
        System.out.println("持久化聊天机器人已启动，输入 'exit' 退出");
        
        while (true) {
            System.out.print("你: ");
            String input = scanner.nextLine();
            
            if (input.equalsIgnoreCase("exit")) {
                System.out.println("聊天结束");
                break;
            }
            
            // 生成响应（记忆会持久化）
            String response = modelWithMemory.generate(input);
            System.out.println("机器人: " + response);
        }
        
        scanner.close();
    }
}

多轮对话管理 ​

带状态管理的聊天机器人 ​

java
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.memory.chat.MessageWindowChatMemory;
import dev.langchain4j.model.chat.ChatLanguageModelWithMemory;
import java.util.HashMap;
import java.util.Map;

public class StatefulChatBot {
    // 对话状态
    private enum ChatState {
        INIT, 
        COLLECTING_INFO, 
        PROVIDING_SERVICE
    }
    
    private static ChatState currentState = ChatState.INIT;
    private static Map<String, String> userInfo = new HashMap<>();
    
    public static void main(String[] args) {
        // 创建模型
        ChatLanguageModel model = OpenAiChatModel.builder()
                .apiKey(System.getenv("OPENAI_API_KEY"))
                .modelName("gpt-3.5-turbo")
                .build();

        // 创建记忆
        MessageWindowChatMemory memory = MessageWindowChatMemory.builder()
                .maxMessages(10)
                .build();

        // 创建带记忆的模型
        ChatLanguageModelWithMemory modelWithMemory = ChatLanguageModelWithMemory.builder()
                .chatLanguageModel(model)
                .chatMemory(memory)
                .build();

        // 聊天循环
        Scanner scanner = new Scanner(System.in);
        System.out.println("带状态管理的聊天机器人已启动，输入 'exit' 退出");
        
        while (true) {
            System.out.print("你: ");
            String input = scanner.nextLine();
            
            if (input.equalsIgnoreCase("exit")) {
                System.out.println("聊天结束");
                break;
            }
            
            // 根据当前状态处理输入
            String response = processInput(input, modelWithMemory);
            System.out.println("机器人: " + response);
        }
        
        scanner.close();
    }
    
    private static String processInput(String input, ChatLanguageModelWithMemory model) {
        switch (currentState) {
            case INIT:
                userInfo.clear();
                currentState = ChatState.COLLECTING_INFO;
                return "你好！我是你的个人助手。为了更好地帮助你，我需要了解一些基本信息。你叫什么名字？";
                
            case COLLECTING_INFO:
                if (!userInfo.containsKey("name")) {
                    userInfo.put("name", input);
                    return "很高兴认识你，" + input + "！你从事什么工作？";
                } else if (!userInfo.containsKey("job")) {
                    userInfo.put("job", input);
                    currentState = ChatState.PROVIDING_SERVICE;
                    return "好的，" + userInfo.get("name") + "，作为一名" + input + "，我可以为你提供哪些帮助？";
                }
                break;
                
            case PROVIDING_SERVICE:
                // 使用模型生成响应
                String prompt = "你是一个个人助手，正在与" + userInfo.get("name") + "交谈，他是一名" + userInfo.get("job") + "。请根据以下对话生成响应：" + input;
                return model.generate(prompt);
        }
        
        return "我不太理解，请再说一遍。";
    }
}

带工具的聊天机器人 ​

java
import dev.langchain4j.agent.Agent;
import dev.langchain4j.agent.tool.Tool;
import dev.langchain4j.model.openai.OpenAiChatModel;

public class ToolUsingChatBot {
    public static void main(String[] args) {
        // 创建模型
        OpenAiChatModel model = OpenAiChatModel.builder()
                .apiKey(System.getenv("OPENAI_API_KEY"))
                .modelName("gpt-3.5-turbo")
                .build();

        // 创建工具
        Tool weatherTool = Tool.builder()
                .name("get_weather")
                .description("获取指定城市的天气信息")
                .function(input -> getWeather(input))
                .build();

        Tool calculatorTool = Tool.builder()
                .name("calculate")
                .description("执行数学计算")
                .function(input -> calculate(input))
                .build();

        // 创建代理
        Agent agent = Agent.builder()
                .model(model)
                .tools(Arrays.asList(weatherTool, calculatorTool))
                .build();

        // 聊天循环
        Scanner scanner = new Scanner(System.in);
        System.out.println("带工具的聊天机器人已启动，输入 'exit' 退出");
        
        while (true) {
            System.out.print("你: ");
            String input = scanner.nextLine();
            
            if (input.equalsIgnoreCase("exit")) {
                System.out.println("聊天结束");
                break;
            }
            
            // 执行任务
            String response = agent.execute(input);
            System.out.println("机器人: " + response);
        }
        
        scanner.close();
    }
    
    private static String getWeather(String city) {
        // 模拟天气查询
        return city + "的天气晴朗，温度 25 度，微风。";
    }
    
    private static String calculate(String expression) {
        // 简单的数学计算
        try {
            // 这里使用脚本引擎执行计算
            javax.script.ScriptEngineManager manager = new javax.script.ScriptEngineManager();
            javax.script.ScriptEngine engine = manager.getEngineByName("JavaScript");
            Object result = engine.eval(expression);
            return "计算结果: " + result;
        } catch (Exception e) {
            return "计算错误: " + e.getMessage();
        }
    }
}

最佳实践 ​

  1. 用户体验：

    • 提供友好的欢迎消息
    • 保持响应简洁明了
    • 处理用户输入错误

  2. 上下文管理：

    • 使用记忆机制保持对话连贯性
    • 合理设置记忆大小
    • 实现会话管理

  3. 功能扩展：

    • 集成更多工具
    • 添加个性化功能
    • 支持多语言

  4. 性能优化：

    • 缓存常见问题的回答
    • 优化提示词
    • 合理使用模型

  5. 安全性：

    • 过滤敏感内容
    • 保护用户隐私
    • 防止恶意输入

  6. 部署：

    • 选择合适的部署方式
    • 监控系统运行状态
    • 实现自动扩展

Copyright © 2025-2026 京公网安备 11010102000001号 京ICP备2024078128号-1