1. 项目概述：为什么选择这个技术栈来构建AI智能体？

最近在尝试将AI能力集成到后端服务里，发现了一个挺有意思的组合：用Micronaut做轻量级框架，搭配LangChain4j来处理AI链式调用，再用MCP（Model Context Protocol）来统一管理不同的模型上下文。这个组合听起来有点“混搭”，但实际用下来，你会发现它恰好解决了现代AI应用开发中的几个核心痛点： 轻量快速启动、灵活的AI编排能力，以及模型上下文的标准化管理 。

我最初想解决的问题是，如何在一个典型的Java/Kotlin后端服务里，优雅地接入大语言模型（LLM），并让它能执行一些简单的、有状态的自动化任务，比如根据用户输入自动查询数据库、调用外部API、然后生成结构化的回复。这本质上就是在构建一个“AI智能体”（AI Agent）。市面上方案很多，但要么太重（整套AI平台搬过来），要么太散（自己从零组装HTTP客户端、提示词模板、上下文管理）。而这个由Micronaut、LangChain4j和MCP构成的技术栈，提供了一个相当清爽的解决方案。

简单来说， Micronaut 负责提供高效、编译时依赖注入的运行时容器，让你的服务本身保持轻快； LangChain4j 是一个为Java/Kotlin设计的LangChain移植库，它提供了与AI模型交互、构建链（Chain）和智能体（Agent）所需的各种抽象和工具；而 MCP 则是一个新兴的协议，旨在标准化应用程序与大语言模型之间的上下文交互方式，你可以把它理解为一个“模型上下文的管理层”，让不同的工具和模型能说同一种语言。

这个项目适合已经熟悉Java或Kotlin后端开发，正打算探索AI能力集成的开发者。你不需要是AI专家，但需要对HTTP API、依赖注入等概念有基本了解。接下来，我会详细拆解从环境搭建到核心功能实现的每一步，并分享我在集成过程中踩过的坑和总结的技巧。

2. 技术栈深度解析与选型理由

2.1 Micronaut：为什么不是Spring Boot？

在Java生态里，一提到微服务，Spring Boot几乎是条件反射般的选择。但在这个AI智能体项目里，我选择了Micronaut，主要基于以下几点考量：

启动速度与内存占用 ：AI应用，尤其是涉及大模型调用的场景，往往是I/O密集型（网络请求）而非CPU密集型。Micronaut的编译时（Ahead-of-Time, AOT）处理能力，使得它在启动速度上远超基于运行时反射的Spring Boot。一个简单的Micronaut应用可以在秒级甚至亚秒级启动，这对于需要快速伸缩、应对突发AI请求的云原生环境非常友好。内存占用也更低，这意味着在同等资源下，你可以部署更多的服务实例来处理AI任务。

对响应式编程的原生友好 ：LangChain4j的许多调用，特别是流式响应（Streaming）处理，天然适合用响应式编程模型（如Reactor、RxJava）来表达。Micronaut从设计之初就深度集成了Reactive Streams，其HTTP客户端和服务器对非阻塞I/O的支持非常纯粹。这使得在处理AI模型可能长达数秒甚至更久的响应时，能够更好地利用系统资源，避免线程阻塞。

简洁的配置与模块化 ：Micronaut的配置系统直观，且其模块化设计让我们可以只引入需要的组件。对于这个项目，我们核心需要的是HTTP服务器、依赖注入和配置管理，Micronaut的“瘦身”特性避免了不必要的依赖膨胀。

注意 ：如果你现有的团队和技术栈深度绑定Spring生态，迁移到Micronaut会有学习成本。但对于一个全新的、对性能有要求的AI集成项目，Micronaut的收益是显著的。

2.2 LangChain4j：Java/Kotlin开发者的AI“瑞士军刀”

LangChain4j是LangChain的Java/Kotlin版本。它的核心价值在于提供了一套高级API，将与大语言模型交互的复杂性封装起来。

核心抽象 ：

• ChatLanguageModel ：这是与LLM（如OpenAI GPT、Anthropic Claude、本地部署的Ollama模型）对话的接口。你不需要直接处理HTTP请求和JSON解析。
• PromptTemplate ：管理提示词（Prompt）的模板，支持变量替换，让提示词工程变得可维护。
• Chain ：将多个步骤（如“获取用户输入 -> 用LLM提取意图 -> 调用工具 -> 用LLM格式化结果”）串联起来。
• Tool ：定义智能体可以执行的具体操作（如查询天气、计算、搜索数据库）。这是构建智能体的基石。
• Agent ：一个可以自主决定使用哪些工具来达成目标的智能体。LangChain4j提供了 ReAct 、 AutoGPT 等多种代理执行器。

为什么是LangChain4j而不是直接调用模型API？ 直接调用API（比如用OpenAI的Java SDK）当然可以，但当你的逻辑变得复杂时，代码会迅速变得难以管理。LangChain4j通过 Tool 和 Chain 的抽象，强制你进行关注点分离。工具的实现是纯业务逻辑，而AI的编排则由框架负责。这使得代码更清晰，也更容易测试（你可以单独Mock LLM的响应）。

2.3 MCP：统一上下文管理的“粘合剂”

MCP是一个相对较新的概念。你可以把它想象成AI世界里的“数据库连接协议”（如JDBC），但它是为模型上下文（Context）服务的。

它解决了什么问题？ 不同的AI工具、数据源（如Notion、Confluence、GitHub）都有自己独特的API和数据格式。如果每个工具都直接与LLM交互，你需要为每个工具编写特定的集成代码，并且很难在它们之间共享和组合上下文。MCP定义了一套标准协议，让任何数据源或工具都能以统一的方式向LLM“暴露”自己的上下文和操作能力。

在这个项目中的角色 ： 在我们的智能体中，MCP不是必须的，但它为未来的扩展提供了优雅的路径。例如，你可以实现一个MCP服务器，将公司内部的文档库作为一个“工具”暴露给智能体。智能体通过标准的MCP协议来查询文档，获取相关上下文，而不需要关心文档库的具体实现。LangChain4j社区正在积极集成MCP，这意味着未来我们可以更方便地接入各种MCP兼容的工具。

技术栈协同工作流 ：

1. Micronaut 作为应用容器，接收HTTP请求（例如 POST /chat ）。
2. 控制器（Controller）将请求委托给一个 LangChain4j 构建的 AgentExecutor 。
3. AgentExecutor 根据当前对话历史和用户输入，决定调用哪个 Tool 。
4. Tool 在执行时，可能会通过 MCP 客户端（如果集成了的话）去获取外部系统的上下文信息。
5. Tool 的执行结果和获取的上下文，被组装成新的提示词，通过 ChatLanguageModel 发送给LLM（如OpenAI）。
6. LLM的返回结果经由 AgentExecutor 处理，最终通过Micronaut的控制器返回给用户。

3. 环境搭建与项目初始化

3.1 创建Micronaut项目

首先，确保你安装了JDK 11或更高版本，以及一个喜欢的构建工具（这里以Gradle为例）。使用Micronaut Launch（命令行或网页版）可以快速生成项目骨架。

mn create-app com.example.aiagent \
  --build=gradle_kotlin \
  --lang=kotlin \
  --features=http-client, jackson-databind, reactor

这里我们选择了Kotlin语言，并添加了HTTP客户端、JSON处理（Jackson）和响应式支持（Reactor）等特性。

生成的 build.gradle.kts 文件需要添加LangChain4j等依赖。以下是关键依赖项：

dependencies {
    // Micronaut 核心
    implementation("io.micronaut:micronaut-http-client")
    implementation("io.micronaut:micronaut-jackson-databind")
    implementation("io.micronaut.reactor:micronaut-reactor")

    // LangChain4j 核心
    implementation("dev.langchain4j:langchain4j:0.31.0")
    // LangChain4j OpenAI 集成 (以OpenAI为例)
    implementation("dev.langchain4j:langchain4j-open-ai:0.31.0")
    // LangChain4j 本地模型集成 (如Ollama)
    implementation("dev.langchain4j:langchain4j-ollama:0.31.0")

    // 测试依赖
    testImplementation("io.micronaut:micronaut-http-client")
}

实操心得 ：版本号请务必查阅LangChain4j官方GitHub仓库的最新版本，该库迭代较快。建议锁定版本号以避免意外的不兼容升级。

3.2 配置模型连接

在 src/main/resources/application.yml 中配置你的AI模型连接信息。这里以OpenAI和本地Ollama为例，提供两种配置方式：

micronaut:
  application:
    name: aiagent

openai:
  api-key: ${OPENAI_API_KEY:} # 建议通过环境变量注入
  model: gpt-4o-mini # 或 gpt-4-turbo
  timeout: 60s
  temperature: 0.7

ollama:
  base-url: http://localhost:11434
  model: llama3.2:latest # 或其它本地模型

重要安全提示 ：API密钥等敏感信息绝对不要硬编码在代码或配置文件中提交到版本控制系统。使用环境变量（如 OPENAI_API_KEY ）或专门的密钥管理服务（如HashiCorp Vault、AWS Secrets Manager）是必须遵循的最佳实践。在Micronaut中，可以通过 ${} 语法轻松引用环境变量。

3.3 构建核心Bean：ChatLanguageModel与Tool

在Micronaut中，我们使用 @Factory 或 @Singleton 来创建和管理依赖。

首先，创建一个配置类来根据配置决定使用哪个模型：

package com.example.aiagent.config

import dev.langchain4j.model.chat.ChatLanguageModel
import dev.langchain4j.model.openai.OpenAiChatModel
import dev.langchain4j.model.ollama.OllamaChatModel
import io.micronaut.context.annotation.Factory
import io.micronaut.context.annotation.Requires
import jakarta.inject.Singleton
import java.time.Duration

@Factory
class AiModelFactory {

    @Singleton
    @Requires(property = "openai.api-key")
    fun openAiChatModel(openAiConfig: OpenAiConfig): ChatLanguageModel {
        return OpenAiChatModel.builder()
            .apiKey(openAiConfig.apiKey)
            .modelName(openAiConfig.model)
            .timeout(openAiConfig.timeout)
            .temperature(openAiConfig.temperature)
            .build()
    }

    @Singleton
    @Requires(property = "ollama.base-url")
    fun ollamaChatModel(ollamaConfig: OllamaConfig): ChatLanguageModel {
        return OllamaChatModel.builder()
            .baseUrl(ollamaConfig.baseUrl)
            .modelName(ollamaConfig.model)
            .timeout(Duration.ofSeconds(60))
            .build()
    }
}

// 对应的配置类 OpenAiConfig.kt 和 OllamaConfig.kt (使用@ConfigurationProperties)

接下来，定义一个简单的工具。例如，一个计算器工具：

package com.example.aiagent.tools

import dev.langchain4j.agent.tool.Tool
import org.slf4j.LoggerFactory
import java.time.LocalDateTime
import java.time.format.DateTimeFormatter

class CalculatorTool {

    private val log = LoggerFactory.getLogger(CalculatorTool::class.java)

    @Tool("用于对两个数字进行基本的四则运算。输入两个数字和运算符 (+, -, *, /)。")
    fun calculate(
        @Tool.P("第一个数字") a: Double,
        @Tool.P("第二个数字") b: Double,
        @Tool.P("运算符，必须是 +, -, *, / 中的一个") operator: String
    ): String {
        log.info("Calculator tool invoked with: {} {} {}", a, operator, b)
        return when (operator) {
            "+" -> "结果是: ${a + b}"
            "-" -> "结果是: ${a - b}"
            "*" -> "结果是: ${a * b}"
            "/" -> if (b != 0.0) "结果是: ${a / b}" else "错误：除数不能为零"
            else -> "错误：不支持的运算符 '$operator'。请使用 +, -, *, /。"
        }
    }
}

注意事项 ： @Tool 注解的描述非常重要！LLM（尤其是能力较弱的模型）依赖这些描述来理解何时以及如何使用该工具。描述应清晰、简洁，并说明输入参数的用途。 @Tool.P 注解用于描述参数。

4. 构建与组装AI智能体

4.1 创建智能体执行器（Agent Executor）

智能体的核心是一个执行器，它负责协调工具调用和与LLM的对话。我们使用LangChain4j的 AiServices 来简化这一过程。 AiServices 是一个强大的抽象，可以自动将工具装配到一个接口上。

首先，定义一个代表智能体能力的接口：

package com.example.aiagent.agent

import dev.langchain4j.service.SystemMessage
import dev.langchain4j.service.UserMessage
import dev.langchain4j.service.V

interface Assistant {

    @SystemMessage("""
        你是一个乐于助人的AI助手，可以调用工具来帮助用户解决问题。
        当你被问到需要计算、获取当前时间或执行其他特定操作时，请调用相应的工具。
        你的回答应当友好、简洁且准确。
    """)
    fun chat(@UserMessage userMessage: String): String
}

然后，创建一个Service类，将模型、工具和这个接口绑定起来：

package com.example.aiagent.agent

import dev.langchain4j.model.chat.ChatLanguageModel
import dev.langchain4j.service.AiServices
import com.example.aiagent.tools.CalculatorTool
import com.example.aiagent.tools.TimeTool
import jakarta.inject.Singleton

@Singleton
class AgentService(
    private val model: ChatLanguageModel,
    private val calculatorTool: CalculatorTool,
    private val timeTool: TimeTool // 假设我们还有一个报时工具
) {

    val assistant: Assistant by lazy {
        AiServices.builder(Assistant::class.java)
            .chatLanguageModel(model)
            .tools(calculatorTool, timeTool) // 注册所有工具
            .build()
    }

    fun processQuery(query: String): String {
        return assistant.chat(query)
    }
}

AiServices 会在运行时动态生成一个 Assistant 接口的实现。当用户消息传入时，它会自动分析消息，决定是否需要调用工具、调用哪个工具，并处理工具返回的结果，必要时进行多轮对话直到得出最终答案。

4.2 暴露HTTP端点

最后，我们需要一个Micronaut控制器来接收外部的HTTP请求：

package com.example.aiagent.controller

import com.example.aiagent.agent.AgentService
import io.micronaut.http.annotation.*
import io.micronaut.scheduling.TaskExecutors
import io.micronaut.scheduling.annotation.ExecuteOn
import reactor.core.publisher.Mono

@Controller("/chat")
class ChatController(private val agentService: AgentService) {

    @Post
    @ExecuteOn(TaskExecutors.IO) // 在IO线程池执行，避免阻塞Netty事件循环
    fun chat(@Body request: ChatRequest): Mono<ChatResponse> {
        return Mono.fromCallable {
            val answer = agentService.processQuery(request.message)
            ChatResponse(answer)
        }
    }
}

data class ChatRequest(val message: String)
data class ChatResponse(val answer: String)

这个端点接收一个包含 message 字段的JSON请求，调用 AgentService 进行处理，并以JSON格式返回AI的回复。使用 Mono 和 @ExecuteOn 确保了在处理可能耗时的AI调用时，服务依然能保持响应性。

5. 高级主题：工具设计、流式响应与MCP集成探索

5.1 设计高效、安全的工具

工具是智能体的手脚，设计好坏直接决定智能体的能力上限和安全性。

工具设计原则 ：

1. 单一职责 ：一个工具只做一件事。 CalculateTool 只负责计算， SearchDatabaseTool 只负责查询。这有利于测试和复用。
2. 描述清晰 ： @Tool 注解的描述和参数描述要尽可能精确，减少LLM的误解。
3. 输入验证与净化 ：工具内部必须对输入进行验证。例如，计算器工具要检查除数是否为零；调用外部API的工具要对参数进行编码，防止注入攻击。
4. 异步与超时 ：如果工具需要调用慢速的外部服务（如网络请求），应将其设计为异步的，并设置合理的超时时间。LangChain4j支持返回 CompletableFuture 的工具。
5. 错误处理 ：工具应返回结构化的错误信息，而不是抛出异常。这能让LLM更好地理解失败原因，并向用户给出友好的解释。

示例：一个安全的数据库查询工具 ：

@Tool("根据用户提供的产品名称关键词，在商品数据库中执行安全的模糊查询。")
fun searchProducts(
    @Tool.P("产品名称关键词，将用于安全地构建LIKE查询") keyword: String
): String {
    // 1. 输入净化：移除可能用于SQL注入的特殊字符（这里简单演示，生产环境需用ORM或参数化查询）
    val safeKeyword = keyword.replace("[';\"\\-]", "")
    if (safeKeyword.isBlank()) {
        return "查询关键词不能为空或仅包含无效字符。"
    }
    // 2. 使用参数化查询（假设使用JdbcTemplate或R2dbcEntityOperations）
    val sql = "SELECT id, name, price FROM products WHERE name LIKE ? LIMIT 5"
    val results: List<Product> = // ... 执行查询，使用 `%${safeKeyword}%` 作为参数
    // 3. 格式化结果
    return if (results.isEmpty()) {
        "未找到包含'$safeKeyword'的商品。"
    } else {
        results.joinToString("\n") { "- ${it.name}: \$${it.price}" }
    }
}

5.2 实现流式响应（Streaming）

用户期待与AI对话能有像ChatGPT一样的打字机式流式体验。LangChain4j和Micronaut都支持这一特性。

首先，修改 Assistant 接口和 AgentService 以支持流式响应：

// 在 Assistant 接口中增加流式方法
import dev.langchain4j.service.TokenStream

interface Assistant {
    // ... 原有的 chat 方法
    @SystemMessage("...")
    fun chatStream(@UserMessage userMessage: String): TokenStream
}

// 在 AgentService 中暴露流式方法
@Singleton
class AgentService(
    // ... 依赖
) {
    // ... 原有的 assistant
    fun processQueryStream(query: String): TokenStream {
        return assistant.chatStream(query)
    }
}

然后，创建一个服务器发送事件（Server-Sent Events, SSE）的端点：

@Controller("/chat")
class ChatController(private val agentService: AgentService) {

    @Post("/stream")
    @Produces(MediaType.TEXT_EVENT_STREAM)
    fun chatStream(@Body request: ChatRequest): Flux<ServerSentEvent<String>> {
        return Flux.create({ sink ->
            agentService.processQueryStream(request.message)
                .onNext { token -> sink.next(ServerSentEvent.builder(token).build()) }
                .onComplete { sink.complete() }
                .onError { error -> sink.error(error) }
                .start()
        }, FluxSink.OverflowStrategy.BUFFER)
    }
}

这样，前端就可以通过监听SSE连接，实时接收到AI生成的每一个词元（Token），实现流畅的对话效果。

5.3 探索集成MCP（Model Context Protocol）

MCP的集成目前还在社区推动阶段。其核心思想是运行一个MCP服务器（作为独立进程或内嵌），你的智能体通过标准的MCP客户端与之通信。

简化集成思路 ：

1. 将MCP Server作为工具 ：你可以创建一个 MCPQueryTool ，这个工具的内部实现是使用MCP客户端协议与一个外部的MCP服务器（例如，一个连接了公司Confluence的MCP服务器）进行通信。
2. LangChain4j的未来支持 ：密切关注LangChain4j的更新，官方可能会推出 langchain4j-mcp 模块，提供更原生的集成方式。

当前实现示例（概念性） ：

@Tool("通过MCP协议查询知识库，获取与问题相关的上下文信息。")
fun queryKnowledgeBaseViaMCP(@Tool.P("用户的问题或需要查询的主题") question: String): String {
    // 1. 初始化MCP客户端（假设有Java客户端库）
    val mcpClient = McpClient.connect("localhost:8081") // MCP服务器地址
    // 2. 调用MCP服务器的资源列表或搜索接口
    val context: String = mcpClient.searchContext(question)
    // 3. 返回获取的上下文
    return "根据知识库，相关信息如下：\n$context"
}

这样，你的智能体就具备了通过标准化协议访问外部知识的能力，极大地增强了其应用范围。

6. 测试、部署与性能调优

6.1 编写集成测试

测试AI应用有其特殊性，因为LLM的输出是非确定性的。我们的测试策略应该是：

1. Mock LLM ：在单元测试中，完全Mock掉 ChatLanguageModel ，模拟其返回固定的、预期的内容，来测试工具调用链的逻辑是否正确。
2. 集成测试 ：针对具体的工具进行集成测试，确保它们能正确调用外部服务（如数据库）并返回预期格式。
3. 端到端测试 ：使用真实的LLM（可以是成本较低的模型如gpt-3.5-turbo或本地Ollama模型）进行少量、关键的场景测试，验证整个流程是否通畅。

使用Micronaut和LangChain4j测试工具 ：

@MicronautTest
class CalculatorToolTest {

    @Inject
    lateinit var calculatorTool: CalculatorTool

    @Test
    fun `should add two numbers correctly`() {
        val result = calculatorTool.calculate(5.0, 3.0, "+")
        assertTrue(result.contains("8.0"))
    }

    @Test
    fun `should handle division by zero`() {
        val result = calculatorTool.calculate(5.0, 0.0, "/")
        assertTrue(result.contains("除数不能为零"))
    }
}

6.2 部署考量

• 打包 ：使用Micronaut的 ./gradlew assemble 或 ./mvnw package 生成可执行的JAR文件。得益于Micronaut的AOT编译，这个JAR文件启动非常快。
• 容器化 ：强烈建议使用Docker容器化部署。创建一个基于 eclipse-temurin:21-jre-alpine 等小型JRE镜像的Dockerfile，可以极大地减小镜像体积。
• 配置管理 ：将 OPENAI_API_KEY 等敏感信息通过Kubernetes Secrets、Docker Secrets或云服务商的环境变量注入。
• 健康检查与监控 ：Micronaut内置了 /health 和 /metrics 端点。确保在部署配置中启用它们，并集成到你的监控系统（如Prometheus、Grafana）中，监控服务的响应时间、错误率和LLM API的调用延迟。

6.3 性能调优与成本控制

• 超时与重试 ：为LLM调用配置合理的超时（如30-60秒）和重试策略（针对网络抖动或模型暂时过载）。这可以在创建 ChatLanguageModel 时设置。
• 缓存 ：对于频繁且结果不变的AI请求（例如，将一段固定文本翻译成另一种语言），可以考虑使用缓存。LangChain4j提供了 CacheChatMemoryStore ，可以缓存对话历史。
• 成本控制 ：
  • 使用小模型 ：对于简单任务，优先使用 gpt-4o-mini 或 gpt-3.5-turbo ，而非 gpt-4 。
  • 设置最大Token数 ：在调用模型时，明确设置 maxTokens 参数，防止生成过长的、昂贵的回复。
  • 本地模型兜底 ：对于不敏感的内部任务，可以配置降级策略，当OpenAI服务不可用或成本过高时，自动切换到本地部署的Ollama模型。
• 对话历史管理 ：智能体通常需要记住上下文。LangChain4j的 ChatMemory （如 MessageWindowChatMemory ）可以管理对话历史。但要注意，历史越长，消耗的Token越多，成本越高，且可能影响模型性能。需要根据场景设置合理的记忆窗口大小。

7. 常见问题排查与调试技巧

在实际开发中，你肯定会遇到各种问题。下面是一个快速排查指南：

问题现象	可能原因	排查步骤与解决方案
智能体不调用工具，总是直接回答。	1. 工具描述不够清晰。 2. LLM能力不足（如使用了非常小的模型）。 3. 系统提示词（SystemMessage）未明确指示使用工具。	1. 检查并优化 @Tool 注解的描述，确保无歧义。 2. 尝试更换为能力更强的模型（如从 gpt-3.5-turbo 切换到 gpt-4 ）。 3. 强化系统提示词，例如：“你必须使用工具来回答问题。当用户的问题涉及计算、查询等操作时，优先调用工具。”
工具被调用，但参数传递错误。	LLM未能正确理解用户意图并提取参数。	1. 在工具方法中增加日志，打印入参，观察LLM传递了什么。 2. 优化参数描述( @Tool.P )。 3. 考虑在提示词中提供更明确的示例（Few-shot Prompting），但这在 AiServices 中需要更复杂的配置。
流式响应不工作或中断。	1. 网络问题或代理设置。 2. 客户端未正确处理SSE流。 3. 服务端超时设置过短。	1. 检查服务端日志是否有异常。用 curl 或Postman测试SSE端点。 2. 确保前端使用 EventSource 或类似库正确接收数据。 3. 调整Micronaut的HTTP响应超时设置（ micronaut.server.read-timeout ）。
应用启动失败，提示Bean创建错误。	1. 依赖冲突。 2. 配置错误（如API_KEY为空）。 3. Micronaut AOT处理与某些库不兼容。	1. 运行 ./gradlew dependencies 检查依赖树。 2. 确认环境变量或配置文件已正确设置。 3. 尝试暂时禁用某个特定的Micronaut特性，或检查相关库是否有Micronaut专用版本。
调用OpenAI API超时。	1. 网络连接问题。 2. OpenAI服务端响应慢。 3. 请求的Token数过多（上下文太长）。	1. 测试网络到 api.openai.com 的通畅性。 2. 在OpenAI控制台查看服务状态。 3. 检查 ChatMemory 的大小，限制历史消息条数或总Token数。

调试利器：开启详细日志 在 application.yml 中，将LangChain4j和你的应用日志级别调为 DEBUG 或 TRACE ，可以清晰地看到工具调用的决策过程、发送给LLM的完整提示词以及LLM的原始响应，这对调试复杂问题至关重要。

logging:
  level:
    root: INFO
    com.example.aiagent: DEBUG
    dev.langchain4j: DEBUG # 查看LangChain4j内部流程

构建一个由Micronaut、LangChain4j和MCP组成的AI智能体，是一个将现代云原生Java开发与前沿AI能力相结合的高效实践。这个架构不仅保证了应用本身的性能和可维护性，还通过LangChain4j获得了强大的AI编排能力，并通过MCP预留了与更广阔AI工具生态集成的可能性。从简单的计算工具开始，逐步扩展到连接数据库、内部API乃至整个知识库，这个轻量级框架能够伴随你的AI需求一起成长。最关键的是，整个开发体验非常“Java/Kotlin”，不需要你跳出熟悉的生态系统，就能快速构建出实用、智能的后端服务。