Adding Langchain4J + MCP support

Author: dantelmomsft

README.md

@@ -19,7 +19,7 @@ products:
 - azure-monitor
 - azure-pipelines
 urlFragment: agent-openai-java-banking-assistant
-name: Multi Agents Banking Assistant with Java and Semantic Kernel
+name: Multi Agents Banking Assistant with Java and Langchain4j
 description: A Java sample app emulating a personal banking AI-powered assistant to inquire about account balances, review recent transactions, or initiate payments
 ---
 <!-- YAML front-matter schema: https://review.learn.microsoft.com/en-us/help/contribute/samples/process/onboarding?branch=main#supported-metadata-fields-for-readmemd -->
@@ -28,7 +28,7 @@ description: A Java sample app emulating a personal banking AI-powered assistant
 
 ![](./docs/assets/robot-agents-small.png)
 
-# Multi Agents Banking Assistant with Java and Semantic Kernel
+# Multi Agents Banking Assistant with Java and Langchain4j
 
 [![Open project in GitHub Codespaces](https://img.shields.io/badge/Codespaces-Open-blue?style=flat-square&logo=github)](https://codespaces.new/azure-samples/agent-openai-java-banking-assistant?hide_repo_select=true&ref=main&quickstart=true)
 [![Build Status](https://img.shields.io/github/actions/workflow/status/azure-samples/agent-openai-java-banking-assistant/azure-dev.yaml?style=flat-square&label=Build)](https://github.com/azure-samples/agent-openai-java-banking-assistant/actions)
@@ -44,7 +44,8 @@ description: A Java sample app emulating a personal banking AI-powered assistant
 ![](./docs/assets/ui.gif)
 </div>
 
-This project is designed as a Proof of Concept (PoC) to explore the innovative realm of generative AI within the context of multi-agent architectures. By leveraging Java and Microsoft Semantic Kernel AI orchestration framework, our aim is to build a chat web app to demonstrate the feasibility and reliability of using generative AI agents to transform user experience from web clicks to natural language conversations while maximizing reuse of the existing workload data and APIs.
+> [!NOTE]  
+> Java Semantic Kernel version has been moved in a dedicated [branch](https://github.com/Azure-Samples/agent-openai-java-banking-assistant/tree/semantic-kernel)
 
 
 
@@ -53,36 +54,35 @@ The core use case of this Proof of Concept (PoC) revolves around a banking perso
 
 Instead of navigating through traditional web interfaces and menus, users can simply converse with the AI-powered assistant to inquire about their account balances, review recent transactions, or initiate payments. This approach not only enhances user experience by making financial management more intuitive and accessible but also leverages the existing workload data and APIs to ensure a reliable and secure service.
 
-Invoices samples are included in the data folder to make it easy to explore payments feature. The payment agent equipped with OCR tools ( Azure Document Intelligence) will lead the conversation with the user to extract the invoice data and initiate the payment process. Other account fake data as transactions, payment methods and account balance are also available to be queried by the user. All data and services are exposed as external REST APIs and consumed by the agents to provide the user with the requested information.
+Invoices samples are included in the data folder to make it easy to explore payments feature. The payment agent equipped with OCR tools ( Azure Document Intelligence) will lead the conversation with the user to extract the invoice data and initiate the payment process. Other account fake data as transactions, payment methods and account balance are also available to be queried by the user. All data and services are exposed as external REST APIs and **MCP tools** consumed by the agents to provide the user with the requested information.
 
 ## Features 
 This project provides the following features and technical patterns:
- - Simple multi ai agents Java implementation using *gpt-4o-mini* on Azure Open AI.
+ - Simple multi-agent supervisor architecture using *gpt-4o-mini* or *gpt-4o* on Azure Open AI.
+ - Exposing your business API as MCP tools for your agents using [spring-ai-mcp](https://docs.spring.io/spring-ai/reference/api/mcp/mcp-overview.html)
  - Chat intent extraction and agent routing.
- - Agents tools configuration and automatic tools invocations with [Java Semantic Kernel](https://github.com/microsoft/semantic-kernel-java/).
- - Tools output cache scoped at chat conversation level.It improves functions call planning and parameters extraction for long chat.
+ - Agents tools configuration and automatic tools invocations with [Langchain4j](https://github.com/langchain4j/langchain4j).
  - Chat based conversation implemented as [React Single Page Application](https://react.fluentui.dev/?path=/docs/concepts-introduction--docs) with support for images upload.Supported images are invoices, receipts, bills jpeg/png files you want your virtual banking assistant to pay on your behalf.
  - Images scanning and data extraction with Azure Document Intelligence using [prebuilt-invoice](https://learn.microsoft.com/en-us/azure/ai-services/document-intelligence/concept-invoice?view=doc-intel-4.0.0) model.
- - Import REST api contracts (OpenAPI yaml files) as agent tools, providing automatic rest client call. It uses code from Java Semantic Kernel [open-api-plugin code sample](https://github.com/microsoft/semantic-kernel-java/tree/main/samples/semantickernel-sample-plugins/semantickernel-openapi-plugin).
  - Add a copilot app side-by-side to your existing business microservices hosted on [Azure Container Apps](https://azure.microsoft.com/en-us/products/container-apps).
  - Automated Azure resources creation and solution deployment leveraging [Azure Developer CLI](https://learn.microsoft.com/en-us/azure/developer/azure-developer-cli/).
 
 For complex agents conversation implementation, read more about [Autogen framework](https://github.com/microsoft/autogen).
 
 ### Architecture
-![HLA](docs/assets/HLA.png)
+![HLA](docs/assets/HLA-MCP.png)
 The personal banking assistant is designed as a [vertical multi-agent system](./docs/multi-agents/introduction.md), with each agent specializing in a specific functional domain (e.g., account management, transaction history, payments). The architecture consists of the following key components:
 
 - **Copilot Assistant Copilot App (Microservice)**: Serves as the central hub for processing user requests. It's a spring boot application implementing a vertical multi-agent architectures using Java Semantic Kernel to create Agents equipped with tools. in Java the Agent Router to understand user intent from chat interactions and routes the request to the appropriate domain-specific agent.
-    - **Agent Router**: Acts as a user proxy, interpreting user intent based on chat inputs and directing the request to the specific domain agent. This component ensures that user queries are efficiently handled by the relevant agent. It uses **IntentExtractor** tool backed by GPT4 model to extract the user intent in a json format. If intent is 'None' clarifying questions are provided. 
-
+    - **Supervisor Agent**: Acts as a user proxy, interpreting user intent based on chat inputs and directing the request to the specific domain agent. This component ensures that user queries are efficiently handled by the relevant agent. Agents are engaged byt the supervisor in a single turn conversation meaning that only one is selected by the supervisor to answer to user task. It’s just doing routing logic, assuming the domain agent will either carry-on the task in one shot or will involve user feedback if data oversight or action approval (like payment submit) is required.
+    
     - **Account Agent**: Specializes in handling tasks related to banking account information, credit balance, and registered payment methods. It leverages specific Account service APIs to fetch and manage account-related data. Semantic Kernel HTTP plugin is used to create a tool definition from the rest api yaml contract (Open API specification) and automatically call the HTTP endpoint with input parameters extracted by gpt4 model from the chat conversation.
 
     - **Transactions Agent**: Focuses on tasks related to querying user bank movements, including income and outcome payments. This agent accesses account api to retrieve accountid and transaction history service to search for transactions and present them to the user.
 
     - **Payments Agent**: Dedicated to managing tasks related to submitting payments. It interacts with multiple APIs and tools, such as ScanInvoice (backed by Azure Document Intelligence), Account Service to retrieve account and payment methods info, Payment Service to submit payment processing and Transaction History service to check for previous paid invoices.
 
-- **Existing Business APIs**: Interfaces with the backend systems to perform operations related to personal banking accounts, transactions, and invoice payments. These APIs are implemented as external spring boot microservices providing the necessary data and functionality consumed by agents to execute their tasks.
+- **Existing Business APIs**: Interfaces with the backend systems to perform operations related to personal banking accounts, transactions, and invoice payments. These APIs are implemented as external spring boot microservices providing the necessary data and functionality consumed by agents to execute their tasks. They are exposed both as traditional RESTs API and as MCP tools to be consumed by agents.
     - **Account Service (Microservice)**: Provides functionalities like retrieving account details by username, fetching payment methods, and getting registered beneficiaries. This microservice supports all 3 agents.
 
     - **Payments Service (Microservice)**: Offers capabilities to submit payments and notify transactions. It is a critical component for the Payments Agent to execute payment-related tasks efficiently.

app/business-api/account/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-parent</artifactId>
-        <version>2.7.13</version>
+        <version>3.3.6</version>
     </parent>
 
     <groupId>com.microsoft.openai.samples.assistant.business</groupId>
@@ -18,8 +18,24 @@
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 
     </properties>
-    
+
+    <dependencyManagement>
+        <dependencies>
+            <dependency>
+                <groupId>org.springframework.ai</groupId>
+                <artifactId>spring-ai-bom</artifactId>
+                <version>1.0.0-SNAPSHOT</version>
+                <type>pom</type>
+                <scope>import</scope>
+            </dependency>
+        </dependencies>
+    </dependencyManagement>
+
     <dependencies>
+        <dependency>
+            <groupId>org.springframework.ai</groupId>
+            <artifactId>spring-ai-starter-mcp-server-webmvc</artifactId>
+        </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-web</artifactId>
@@ -35,4 +51,33 @@
         </plugins>
     </build>
 
+    <repositories>
+        <repository>
+            <name>Central Portal Snapshots</name>
+            <id>central-portal-snapshots</id>
+            <url>https://central.sonatype.com/repository/maven-snapshots/</url>
+            <releases>
+                <enabled>false</enabled>
+            </releases>
+            <snapshots>
+                <enabled>true</enabled>
+            </snapshots>
+        </repository>
+        <repository>
+            <id>spring-milestones</id>
+            <name>Spring Milestones</name>
+            <url>https://repo.spring.io/milestone</url>
+            <snapshots>
+                <enabled>false</enabled>
+            </snapshots>
+        </repository>
+        <repository>
+            <id>spring-snapshots</id>
+            <name>Spring Snapshots</name>
+            <url>https://repo.spring.io/snapshot</url>
+            <releases>
+                <enabled>false</enabled>
+            </releases>
+        </repository>
+    </repositories>
 </project>

app/business-api/account/src/main/java/com/microsoft/openai/samples/assistant/business/mcp/config/MCPServerConfiguration.java

@@ -0,0 +1,24 @@
+package com.microsoft.openai.samples.assistant.business.mcp.config;
+
+
+import com.microsoft.openai.samples.assistant.business.mcp.server.AccountMCPService;
+import com.microsoft.openai.samples.assistant.business.mcp.server.UserMCPService;
+import org.springframework.ai.tool.ToolCallbackProvider;
+import org.springframework.ai.tool.method.MethodToolCallbackProvider;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class MCPServerConfiguration {
+
+    @Bean
+    public ToolCallbackProvider accountTools(AccountMCPService accountMCPService) {
+        return MethodToolCallbackProvider.builder().toolObjects(accountMCPService).build();
+    }
+
+    @Bean
+    public ToolCallbackProvider userTools(UserMCPService userMCPService) {
+        return MethodToolCallbackProvider.builder().toolObjects(userMCPService).build();
+    }
+
+}

app/business-api/account/src/main/java/com/microsoft/openai/samples/assistant/business/mcp/server/AccountMCPService.java

@@ -0,0 +1,35 @@
+package com.microsoft.openai.samples.assistant.business.mcp.server;
+
+import com.microsoft.openai.samples.assistant.business.models.Account;
+import com.microsoft.openai.samples.assistant.business.models.Beneficiary;
+import com.microsoft.openai.samples.assistant.business.models.PaymentMethod;
+import com.microsoft.openai.samples.assistant.business.service.AccountService;
+import org.springframework.stereotype.Service;
+import org.springframework.ai.tool.annotation.Tool;
+
+import java.util.List;
+
+@Service
+public class AccountMCPService {
+
+    private final AccountService accountService;
+    public AccountMCPService(AccountService accountService) {
+       this.accountService = accountService;
+    }
+
+    @Tool(description = "Get account details and available payment methods")
+    public Account getAccountDetails(String accountId) {
+        return this.accountService.getAccountDetails(accountId);
+
+    }
+
+    @Tool(description = "Get payment method detail with available balance")
+    public PaymentMethod getPaymentMethodDetails(String paymentMethodId) {
+       return this.accountService.getPaymentMethodDetails(paymentMethodId);
+    }
+
+    @Tool(description = "Get list of registered beneficiaries for a specific account")
+    public List<Beneficiary> getRegisteredBeneficiary(String accountId) {
+     return this.accountService.getRegisteredBeneficiary(accountId);
+    }
+}

app/business-api/account/src/main/java/com/microsoft/openai/samples/assistant/business/mcp/server/UserMCPService.java

@@ -0,0 +1,29 @@
+package com.microsoft.openai.samples.assistant.business.mcp.server;
+
+import com.microsoft.openai.samples.assistant.business.models.Account;
+import com.microsoft.openai.samples.assistant.business.service.UserService;
+import org.springframework.ai.tool.annotation.Tool;
+import org.springframework.ai.tool.annotation.ToolParam;
+import org.springframework.stereotype.Service;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+
+@Service
+public class UserMCPService {
+    private final UserService userService;
+
+    public UserMCPService(UserService userService) {
+        this.userService = userService;
+     }
+
+     @Tool(description = "Get the list of all accounts for a specific user")
+    public List<Account> getAccountsByUserName(@ToolParam( description ="userName once the user has logged" ) String userName) {
+        return userService.getAccountsByUserName(userName);
+    }
+
+
+}

app/business-api/account/src/main/java/com/microsoft/openai/samples/assistant/business/models/Account.java

@@ -1,18 +1,21 @@
 package com.microsoft.openai.samples.assistant.business.models;
 
 
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
 import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.annotation.JsonProperty;
 
 import java.util.List;
 
 @JsonInclude(JsonInclude.Include.NON_NULL)
+@JsonIgnoreProperties(ignoreUnknown = true)
 public record Account(
-    String id,
-    String userName,
-    String accountHolderFullName,
-    String currency,
-    String activationDate,
-    String balance,
+        @JsonProperty("id") String id,
+        @JsonProperty("userName") String userName,
+        @JsonProperty("accountHolderFullName") String accountHolderFullName,
+        @JsonProperty("currency") String currency,
+        @JsonProperty("activationDate") String activationDate,
+        @JsonProperty("balance") String balance,
     List<PaymentMethodSummary> paymentMethods
 ) {}
 

app/business-api/account/src/main/java/com/microsoft/openai/samples/assistant/business/models/Beneficiary.java

@@ -1,12 +1,15 @@
 package com.microsoft.openai.samples.assistant.business.models;
 
 
-import java.util.List;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonProperty;
 
+
+@JsonIgnoreProperties(ignoreUnknown = true)
 public record Beneficiary(
-    String id,
-    String fullName,
-    String bankCode,
-    String bankName
+        @JsonProperty("id") String id,
+        @JsonProperty("fullName") String fullName,
+        @JsonProperty("bankCode") String bankCode,
+        @JsonProperty("bankName") String bankName
 ) {}
 

app/business-api/account/src/main/java/com/microsoft/openai/samples/assistant/business/models/PaymentMethod.java

@@ -1,16 +1,19 @@
 package com.microsoft.openai.samples.assistant.business.models;
 
 
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
 import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.annotation.JsonProperty;
 
 @JsonInclude(JsonInclude.Include.NON_NULL)
+@JsonIgnoreProperties(ignoreUnknown = true)
 public record PaymentMethod(
-    String id,
-    String type,
-    String activationDate,
-    String expirationDate,
-    String availableBalance,
+        @JsonProperty("id") String id,
+        @JsonProperty("type") String type,
+        @JsonProperty("activationDate") String activationDate,
+        @JsonProperty("expirationDate") String expirationDate,
+        @JsonProperty("availableBalance") String availableBalance,
     // card number is valued only for credit card type
-    String cardNumber
+        @JsonProperty("cardNumber") String cardNumber
 ) {}
 

app/business-api/account/src/main/java/com/microsoft/openai/samples/assistant/business/models/PaymentMethodSummary.java

@@ -1,10 +1,13 @@
 package com.microsoft.openai.samples.assistant.business.models;
 
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonProperty;
 
+@JsonIgnoreProperties(ignoreUnknown = true)
 public record PaymentMethodSummary(
-    String id,
-    String type,
-    String activationDate,
-    String expirationDate
+        @JsonProperty("id") String id,
+        @JsonProperty("type") String type,
+        @JsonProperty("activationDate") String activationDate,
+        @JsonProperty("expirationDate") String expirationDate
 ) {}
 

app/business-api/account/src/main/resources/application-dev.properties

@@ -1 +1 @@
-server.port=8070
+server.port=8070