1.1 聊起来先

复制
λ ~/Desktop/jaguarliu/core/hi-agent-java/ tree
.
├── pom.xml
└── src
    ├── main
    │   ├── java
    │   │   └── com
    │   │       └── rookie
    │   │           └── stack
    │   │               └── Main.java
    │   └── resources
    └── test
        └── java
 
9 directories, 2 files

复制
<dependency>
  <groupId>com.openai</groupId>
  <artifactId>openai-java</artifactId>
  <version>4.33.0</version>
</dependency>

复制
OPENAI_BASE_URL=https://api.deepseek.com
OPENAI_API_KEY=sk-用自己的API-KEY
OPENAI_MODEL=deepseek-v4-pro

复制
<dependency>
    <groupId>io.github.cdimascio</groupId>
    <artifactId>dotenv-java</artifactId>
    <version>3.2.0</version>
</dependency>

复制
import io.github.cdimascio.dotenv.Dotenv;
import java.nio.file.Path;
 
public record OpenAiConfig(String baseUrl, String apiKey, String model) {
 
    public OpenAiConfig {
        baseUrl = requireNonBlank(baseUrl, "baseUrl");
        apiKey = requireNonBlank(apiKey, "apiKey");
        model = requireNonBlank(model, "model");
    }
 
    public static OpenAiConfig load() {
        return load(Path.of("."));
    }
 
    public static OpenAiConfig load(Path directory) {
        Dotenv dotenv = Dotenv.configure()
                .directory(directory.toAbsolutePath().toString())
                .filename(".env")
                .ignoreIfMissing()
                .load();
 
        return new OpenAiConfig(
                requiredConfig(dotenv, "OPENAI_BASE_URL"),
                requiredConfig(dotenv, "OPENAI_API_KEY"),
                requiredConfig(dotenv, "OPENAI_MODEL"));
    }
 
    private static String requiredConfig(Dotenv dotenv, String key) {
        String value = dotenv.get(key);
        if (value == null || value.isBlank()) {
            throw new IllegalStateException("Missing required config: " + key);
        }
        return value.trim();
    }
 
    private static String requireNonBlank(String value, String fieldName) {
        if (value == null || value.isBlank()) {
            throw new IllegalArgumentException(fieldName + " must not be blank");
        }
        return value.trim();
    }
}

复制
public final class OpenAiChatClient implements AutoCloseable {
 
    private final OpenAIClient client;
    private final String model;
 
    public OpenAiChatClient(OpenAIClient client, String model) {
        this.client = Objects.requireNonNull(client, "client must not be null");
        this.model = requireNonBlank(model, "model");
    }
 
    public static OpenAiChatClient fromEnvFile() {
        OpenAiConfig config = OpenAiConfig.load();
        OpenAIClient client = OpenAIOkHttpClient.builder()
                .baseUrl(config.baseUrl())
                .apiKey(config.apiKey())
                .build();
 
        return new OpenAiChatClient(client, config.model());
    }
 
    public String chat(String userPrompt) {
        String normalizedPrompt = requireNonBlank(userPrompt, "userPrompt");
 
        ChatCompletion completion = client.chat()
                .completions()
                .create(ChatCompletionCreateParams.builder()
                        .model(model)
                        .addUserMessage(normalizedPrompt)
                        .build());
 
        return completion.choices().stream()
                .findFirst()
                .map(ChatCompletion.Choice::message)
                .flatMap(message -> message.content())
                .filter(content -> !content.isBlank())
                .orElseThrow(() -> new IllegalStateException("AI response did not contain assistant content"));
    }
 
    @Override
    public void close() {
        client.close();
    }
 
    private static String requireNonBlank(String value, String fieldName) {
        if (value == null || value.isBlank()) {
            throw new IllegalArgumentException(fieldName + " must not be blank");
        }
        return value.trim();
    }
}

复制
class OpenAiChatClientLiveTest {
 
    private static final Logger log = LoggerFactory.getLogger(OpenAiChatClientLiveTest.class);
 
    @Test
    @EnabledIfSystemProperty(named = "openai.live.test", matches = "true")
    void performsRealChatCompletion() {
        try (OpenAiChatClient client = OpenAiChatClient.fromEnvFile()) {
            String reply = client.chat("你好呀～");
 
            System.out.println(reply);
 
            assertNotNull(reply);
            assertFalse(reply.isBlank());
        }
    }
}

复制
你好呀！👋 很高兴见到你～
 
我是DeepSeek，一个热心的AI助手。无论你想聊天、问问题、找资料，还是需要帮忙写作、分析、头脑风暴，我都随时准备着！
 
今天有什么我可以帮你的吗？或者就是想随便聊聊也完全没问题～ 😊
 
Process finished with exit code 0

复制
enum ChatRole {
    USER,
    ASSISTANT
}

复制
record ChatMessage(ChatRole role, String content) {
 
    ChatMessage {
        Objects.requireNonNull(role, "role must not be null");
        if (content == null || content.isBlank()) {
            throw new IllegalArgumentException("content must not be blank");
        }
        content = content.trim();
    }
}

复制
public String chat(String userPrompt)

复制
public String chat(List<ChatMessage> messages)

复制
public String chat(List<ChatMessage> messages) {
    if (messages == null || messages.isEmpty()) {
        throw new IllegalArgumentException("messages must not be empty");
    }
 
    ChatCompletionCreateParams.Builder builder = ChatCompletionCreateParams.builder().model(model);
    for (ChatMessage message : messages) {
        if (message.role() == ChatRole.USER) {
            builder.addUserMessage(message.content());
        } else if (message.role() == ChatRole.ASSISTANT) {
            builder.addAssistantMessage(message.content());
        } else {
            throw new IllegalArgumentException("Unsupported chat role: " + message.role());
        }
    }
 
    ChatCompletion completion = client.chat()
            .completions()
            .create(builder.build());
 
    return completion.choices().stream()
            .findFirst()
            .map(ChatCompletion.Choice::message)
            .flatMap(message -> message.content())
            .filter(content -> !content.isBlank())
            .orElseThrow(() -> new IllegalStateException("AI response did not contain assistant content"));
}

复制
public final class OpenAiChatSession {
 
    private final OpenAiChatClient client;
    private final List<ChatMessage> history = new ArrayList<>();
 
    public OpenAiChatSession(OpenAiChatClient client) {
        this.client = Objects.requireNonNull(client, "client must not be null");
    }
 
    public String send(String userInput) {
        ChatMessage userMessage = new ChatMessage(ChatRole.USER, userInput);
        List<ChatMessage> requestMessages = new ArrayList<>(history);
        requestMessages.add(userMessage);
 
        String reply = client.chat(requestMessages);
        history.add(userMessage);
        history.add(new ChatMessage(ChatRole.ASSISTANT, reply));
        return reply;
    }
 
    List<ChatMessage> history() {
        return List.copyOf(history);
    }
}

复制
public String send(String userInput)

复制
public class Main {
    public static void main(String[] args) {
        try (OpenAiChatClient client = OpenAiChatClient.fromEnvFile();
             BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) {
 
            OpenAiChatSession session = new OpenAiChatSession(client);
            System.out.println("Chat started. Type 'exit' to quit.");
 
            while (true) {
                System.out.print("You: ");
                String line = reader.readLine();
                if (line == null) {
                    System.out.println();
                    break;
                }
 
                String input = line.trim();
                if (input.isEmpty()) {
                    continue;
                }
                if ("exit".equals(input)) {
                    break;
                }
 
                try {
                    String reply = session.send(input);
                    System.out.println("AI: " + reply);
                } catch (Exception exception) {
                    System.out.println("AI error: " + exception.getMessage());
                }
            }
        } catch (Exception exception) {
            System.err.println("Failed to start chat: " + exception.getMessage());
        }
    }
}

复制
Chat started. Type 'exit' to quit.
You: 你好，我是jaguar，你介绍下你自己
AI: 你好，Jaguar！很高兴认识你。
 
我是 **DeepSeek**，一个由深度求索公司倾心打造的 AI 助手。你可以把我理解为一个住在你手机或电脑里的智能伙伴。
 
简单介绍下我自己：
 
-   **我的核心能力**：
    -   **海量“内存”**：我拥有 1M 的上下文处理能力，可以一次性帮你读完像《三体》三部曲那么大体量的书籍，并回答其中的细节。
    -   **多才多艺**：我擅长文字交流、知识问答、创意写作、代码编写、逻辑推理，甚至还能陪你闲聊解闷。
    -   **文件处理**：虽然我不支持多模态图像识别，但我能读取你上传的图片、PDF、Word、Excel、PPT 等文件里的文字信息，帮你整理和分析。
    -   **联网搜索**：如果你需要最新的信息，记得在网页端或 App 上手动打开联网搜索按键，我就能帮你梳理全网资讯。
 
-   **我的性格特点**：
    -   **完全免费**：目前没有任何收费计划，你可以尽情使用。
    -   **热情细腻**：我会尽力用温暖、友好的方式和你交流。
    -   **支持语音**：在 App 端（官方应用商店可下载）可以直接用语音和我聊天，很方便。
 
怎么样？如果你有任何想聊的话题、想解决的问题，或者只是想找个伴说说话，随时可以丢给我。
 
有什么我可以立刻为你效劳的吗？
You: 你知道今天是几月几号吗
AI: 抱歉，Jaguar，我目前无法直接知道确切的日期。作为一个AI模型，我没有内置的实时时钟，也无法主动获取系统时间。
 
不过，如果你需要知道今天的日期，可以**开启联网搜索功能**，我就能帮你查到准确的时间。或者你也可以直接告诉我今天是几月几号，我很乐意帮你安排日程、计算日期，或者做任何与时间相关的规划！
You: 你还记得我是谁吗
AI: 当然记得，Jaguar！在这一轮对话里，你一开始就告诉我你是 **jaguar**，所以我一直记着你的名字。
 
不过，要诚实地告诉你，我的记忆只在当前这次聊天中有效。一旦对话结束、窗口关闭或会话超时，我就会忘记这次聊天的所有细节。下次你再来找我时，我可能就认不出你了，除非你再次告诉我你的名字。
 
如果你希望我长期记住一些关键信息（比如你的偏好、重要事项等），可以随时把你希望我记的东西整理成文本发给我，然后由你自己保存下来，下次需要时再复制给我——我可以帮你把这些要点整理好。这样你就能在未来的对话中快速让我“恢复记忆”了。
 
有什么想聊的吗？我随时在。
You: