AI购物助手

• "Compare S24 Ultra prices"           → Searches all 4 platforms
• "Search on Amazon for S24"           → Searches Amazon only
• "What's on Flipkart?"               → Searches Flipkart
• "Details for FK-S24U-256"            → Gets full product specs
• "Buy the Flipkart S24 Ultra"        → Starts AP2 payment flow

# Install Ollama from https://ollama.com
# Then download the model:
ollama pull llama3.2:3b    # Downloads a 2GB model
ollama serve               # Starts the API server

// Example: Send a message to the LLM with tools
String response = chatClient.prompt()
    .user("Compare S24 Ultra prices")     // User's question
    .call()                                // Send to Ollama
    .content();                            // Get the response text

MCP Client ──SSE──→ MCP Server
   (port 8080)         (port 8081)

@Tool(description = "Search for Samsung phones on Amazon India")
public String searchAmazon(@ToolParam(description = "Phone name") String productName) {
    // This method runs on the MCP Server when the LLM calls it
    List<Product> products = mockDataProvider.searchAmazon(productName);
    return formatResults(products);
}

{
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "name": "searchAmazon",
    "arguments": { "productName": "S24 Ultra" }
  }
}

┌────────────────────────────────────────────────────────────────────┐
│  BROWSER (index.html)                                              │
│  Dark-themed chat UI with suggestion cards                         │
│  Sends user messages via POST /api/shop                            │
└─────────────────┬──────────────────────────────────────────────────┘
                  │ POST /api/shop {message, conversationId}
                  │ (Standard REST/JSON)
                  ▼
┌────────────────────────────────────────────────────────────────────┐
│  MCP CLIENT (port 8080) — The Orchestrator                         │
│                                                                    │
│  ShoppingController ─→ ShoppingAssistant ─→ Ollama LLM            │
│  (REST API)             (ChatClient +        (llama3.2:3b          │
│                          Memory + Tools)      localhost:11434)      │
│                                                                    │
│  What it does:                                                     │
│  1. Receives user messages via REST API                            │
│  2. Injects system prompt (Samsung expert persona)                 │
│  3. Loads conversation history (last 20 messages)                  │
│  4. Sends prompt + tool definitions to LLM                         │
│  5. When LLM requests a tool call → routes it via MCP to server   │
│  6. Feeds tool result back to LLM                                  │
│  7. Returns LLM's final response to browser                       │
└─────────────────┬──────────────────────────────────────────────────┘
                  │ MCP (SSE Transport)
                  │ JSON-RPC 2.0 over SSE at /sse
                  ▼
┌────────────────────────────────────────────────────────────────────┐
│  MCP SERVER (port 8081) — The Tool Provider                        │
│                                                                    │
│  ┌─────────────┬──────────────┬──────────────┬──────────────┐     │
│  │ AmazonTool  │ FlipkartTool │ SamsungStore │ CromaTool    │     │
│  │             │              │ Tool         │              │     │
│  ├─────────────┼──────────────┼──────────────┴──────────────┤     │
│  │ PriceCompar │ OrderTool    │ AP2PaymentTool              │     │
│  │ ator        │ (details,    │ (intent, cart, payment)     │     │
│  │             │  status)     │                             │     │
│  ├─────────────┴──────────────┴─────────────────────────────┤     │
│  │ McpToolConfig (registers all 10 tools explicitly)        │     │
│  ├──────────────────────────────────────────────────────────┤     │
│  │ MockDataProvider (28 products) │ PaymentService (AP2 PSP)│     │
│  └──────────────────────────────────────────────────────────┘     │
│                                                                    │
│  What it does:                                                     │
│  • Exposes @Tool methods over MCP (SSE transport)                  │
│  • Searches mock product data across 4 platforms                   │
│  • Compares prices with grouping and sorting                       │
│  • Manages AP2 mandate chain for secure payments                   │
│  • Returns formatted text results to the LLM                      │
└────────────────────────────────────────────────────────────────────┘

Browser ──HTTP/JSON──→ MCP Client ──HTTP──→ Ollama (LLM)
                            │
                            └──SSE/JSON-RPC──→ MCP Server (Tools)

POST http://localhost:8080/api/shop
{"message": "Compare S24 Ultra prices", "conversationId": "session-abc123"}

{
  "tool_calls": [{
    "function": {
      "name": "spring_ai_mcp_client_s_comparePrices",
      "arguments": {"productName": "S24 Ultra"}
    }
  }]
}

{
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "name": "comparePrices",
    "arguments": {"productName": "S24 Ultra"}
  }
}

Based on the comparison, here's the best deal for Samsung Galaxy S24 Ultra:

**Best Price:** ₹127,999 (MRP: ₹149,999, 15% off) on Flipkart
  with ₹8,000 off on Axis Bank Card + ₹1,000 off with SuperCoins

Other Options:
• Amazon India: ₹129,999 (13% off)
• Croma: ₹129,999 (13% off)
• Samsung.com India: ₹131,999 (12% off)

Would you like to buy from Flipkart?

# Client configuration (application.yml)
spring.ai.mcp.client:
  type: SYNC
  sse:
    connections:
      s:                            # Short name → keeps tool name prefixes short
        url: http://localhost:8081   # MCP Server address

@Configuration
public class McpToolConfig {
    @Bean
    public ToolCallbackProvider toolCallbackProvider(
            AmazonTool amazonTool, FlipkartTool flipkartTool, /* ... */) {
        return MethodToolCallbackProvider.builder()
            .toolObjects(amazonTool, flipkartTool, cromaTool, samsungStoreTool,
                         priceComparator, orderTool, ap2PaymentTool)
            .build();
    }
}

User says: "Buy the Flipkart S24 Ultra 256GB"

  ┌─────────────────────────────────────────────────────────────┐
  │ STEP 1: createIntentMandate                                  │
  │                                                              │
  │ What:  Captures user's shopping intent + budget              │
  │ Input: intent="Buy Galaxy S24 Ultra from Flipkart"           │
  │        maxBudget=150000, platform="Flipkart"                 │
  │ Output: IM-A1B2C3D4 (SHA-256 signed, timestamped)           │
  │                                                              │
  │ Why:   Creates verifiable proof that the user                │
  │        authorized this purchase with these constraints       │
  └──────────────────────────┬──────────────────────────────────┘
                             │ links to
  ┌──────────────────────────▼──────────────────────────────────┐
  │ STEP 2: createCartMandate                                    │
  │                                                              │
  │ What:  Locks EXACT product, price, quantity                  │
  │ Input: intentMandateId="IM-A1B2C3D4"                        │
  │        productId="FK-S24U-256", quantity=1                   │
  │ Validates:                                                   │
  │   ✅ Intent mandate exists and is valid                      │
  │   ✅ Product exists and is in stock                          │
  │   ✅ Total (₹127,999) doesn't exceed budget (₹150,000)     │
  │ Output: CM-E5F6G7H8 (SHA-256 signed, linked to IM)          │
  │                                                              │
  │ Why:   "What you see is what you pay for"                   │
  │        Price is locked — can't be changed later             │
  └──────────────────────────┬──────────────────────────────────┘
                             │ links to
  ┌──────────────────────────▼──────────────────────────────────┐
  │ STEP 3: processPayment                                       │
  │                                                              │
  │ What:  Validates full chain + processes payment              │
  │ Input: cartMandateId="CM-E5F6G7H8"                          │
  │        paymentMethod="UPI", name, address                    │
  │ Validates:                                                   │
  │   ✅ Cart mandate exists                                     │
  │   ✅ Intent mandate chain is unbroken                        │
  │   ✅ Payment method is valid (UPI/Card/Wallet/NetBanking)   │
  │ Output: TXN-X1Y2Z3A4B5C6 (COMPLETED, full audit trail)     │
  │                                                              │
  │ Audit Trail:                                                 │
  │   IM-A1B2C3D4 → CM-E5F6G7H8 → TXN-X1Y2Z3A4B5C6            │
  │   (intent)       (cart)         (payment)                    │
  │   All cryptographically signed ✅                            │
  └─────────────────────────────────────────────────────────────┘

User: "I want to buy the S24 Ultra from Flipkart, 256GB"

Bot:  🔒 Intent Mandate created: IM-A1B2C3D4
      Intent: "Buy Galaxy S24 Ultra 256GB from Flipkart"
      Budget: ₹150,000 | Signature: 4f8a2b1c... ✅

      🛒 Cart locked: CM-E5F6G7H8
      Product: Samsung Galaxy S24 Ultra (Titanium Gray, 256GB)
      Platform: Flipkart | Price: ₹127,999
      Intent Link: IM-A1B2C3D4 ✅

      Please confirm and tell me:
      • Payment method: UPI / Credit Card / Debit Card
      • Your full name
      • Delivery address with pincode

User: "Confirm. UPI, Harsh Gupta, Bangalore 560001"

Bot:  ✅ PAYMENT SUCCESSFUL (AP2)
      Transaction ID: TXN-X1Y2Z3A4B5C6
      Product: Samsung Galaxy S24 Ultra (256GB)
      Platform: Flipkart | Amount: ₹127,999 | Via: UPI

      🔐 AP2 Audit Trail:
         Intent: IM-A1B2C3D4 ✅
         Cart:   CM-E5F6G7H8 ✅
         Payment: 7c3d9e... ✅

// Sliding window — keeps the last 20 messages per conversation
MessageWindowChatMemory.builder().maxMessages(20).build();

Turn 1: "Compare S24 Ultra prices"     → LLM calls comparePrices, gets data
Turn 2: "Buy the Flipkart one"         → LLM remembers Flipkart had the best price, starts AP2
Turn 3: "UPI, Harsh, Bangalore 560001" → LLM remembers the cart, processes payment

POST http://localhost:8080/api/clear
{"conversationId": "session-abc123"}

spring-ai-mcp-demo/
├── pom.xml                              # Parent POM (multi-module Maven project)
│
├── mcp-server/                          # PORT 8081 — MCP Tool Server
│   ├── pom.xml                         # Server dependencies + maven-compiler-plugin with -parameters
│   └── src/main/java/.../mcpserver/
│       ├── McpServerApplication.java    # Spring Boot entry point
│       ├── McpToolConfig.java          # ★ Explicitly registers all 10 tools via MethodToolCallbackProvider
│       ├── model/
│       │   └── Product.java             # 27-field product model (Lombok @Builder)
│       ├── mock/
│       │   └── MockDataProvider.java    # 28 products, search logic, orders
│       ├── ap2/                         # ★ AP2 Protocol Implementation
│       │   ├── IntentMandate.java       # Step 1: signed user intent (Java record)
│       │   ├── CartMandate.java         # Step 2: signed locked cart (Java record)
│       │   ├── PaymentResult.java       # Step 3: transaction receipt + audit trail (Java record)
│       │   └── PaymentService.java      # Mock PSP with mandate chain validation
│       └── tools/
│           ├── AmazonTool.java          # @Tool: searchAmazon
│           ├── FlipkartTool.java        # @Tool: searchFlipkart
│           ├── SamsungStoreTool.java     # @Tool: searchSamsungStore
│           ├── CromaTool.java           # @Tool: searchCroma
│           ├── PriceComparator.java     # @Tool: comparePrices (searches all 4 platforms)
│           ├── OrderTool.java           # @Tool: getProductDetails, checkOrderStatus
│           ├── AP2PaymentTool.java      # @Tool: createIntentMandate, createCartMandate, processPayment
│           └── ToolOutputHelper.java    # Shared formatting utility for product results
│
└── mcp-client/                          # PORT 8080 — User-facing App
    ├── pom.xml                         # Client dependencies (Spring AI Ollama + MCP Client)
    └── src/main/
        ├── resources/
        │   ├── application.yml          # Ollama + MCP client config
        │   └── static/index.html        # Chat UI (dark theme, suggestion chips)
        └── java/.../mcpclient/
            ├── McpClientApplication.java
            ├── controller/
            │   └── ShoppingController.java  # REST: /api/shop, /api/clear, /api/health
            └── service/
                └── ShoppingAssistant.java   # ChatClient + Memory + System Prompt + MCP Tools

# 1. Install the LLM model (2GB download, one-time)
ollama pull llama3.2:3b

# 2. Make sure Ollama is running
ollama serve

# 3. Clone the project
git clone <repo-url>
cd spring-ai-mcp-demo

# 4. Start the MCP Server (port 8081) — opens a new terminal
cd mcp-server && ../mvnw spring-boot:run

# 5. Start the MCP Client (port 8080) — in another terminal
cd mcp-client && ../mvnw spring-boot:run

# 6. Open the chat UI in your browser
open http://localhost:8080

🔧 [CONFIG] Registering MCP tools...
   → AmazonTool: searchAmazon
   → FlipkartTool: searchFlipkart
   ...
   = 10 tools total
Registered tools: 10
Started McpServerApplication on port 8081

🔧 [SERVICE] MCP tool provider resolved 10 tool callbacks:
   📌 Tool: spring_ai_mcp_client_s_searchAmazon
   📌 Tool: spring_ai_mcp_client_s_comparePrices
   ...
✅ [SERVICE] ShoppingAssistant ready!
Started McpClientApplication on port 8080

curl -X POST http://localhost:8080/api/shop \
  -H "Content-Type: application/json" \
  -d '{"message": "Compare S24 Ultra prices", "conversationId": "test-1"}'

{
  "response": "Here are the best deals for Samsung Galaxy S24 Ultra:\n\n**Best Price:** ₹127,999 on Flipkart...",
  "conversationId": "test-1"
}

curl http://localhost:8080/api/health

curl -X POST http://localhost:8080/api/clear \
  -H "Content-Type: application/json" \
  -d '{"conversationId": "test-1"}'

server:
  port: 8080                          # Client web server port

spring:
  application:
    name: mcp-shopping-client

  ai:
    ollama:
      base-url: http://localhost:11434  # Ollama API endpoint
      chat:
        model: llama3.2:3b              # LLM model to use
        options:
          temperature: 0.7              # Creativity level (0=deterministic, 1=creative)
          num-ctx: 8192                 # Context window size (tokens). Must be large
                                        # enough to fit system prompt + 10 tool definitions
                                        # + conversation history + user message

    mcp:
      client:
        type: SYNC                      # Synchronous MCP client
        sse:
          connections:
            s:                          # ★ Connection name — keep SHORT!
              url: http://localhost:8081 # MCP Server URL

server:
  port: 8081                          # MCP Server port

spring:
  application:
    name: mcp-shopping-server
  ai:
    mcp:
      server:
        name: shopping-tools-server   # Server identity in MCP handshake
        version: 1.0.0
        type: SYNC                    # Synchronous MCP server

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.11.0</version>
    <configuration>
        <parameters>true</parameters>   <!-- ★ Preserves parameter names at runtime -->
    </configuration>                     <!-- Without this, @ToolParam args become arg0, arg1 -->
</plugin>

<!-- MCP Server -->
spring-boot-starter-web              <!-- REST endpoints + Tomcat -->
spring-ai-starter-mcp-server-webmvc  <!-- MCP server with SSE transport -->
lombok                               <!-- @Builder, @Getter for Product model -->

<!-- MCP Client -->
spring-boot-starter-web              <!-- REST endpoints + Tomcat -->
spring-ai-starter-mcp-client         <!-- MCP client with SSE support -->
spring-ai-ollama-spring-boot-starter <!-- Ollama LLM integration -->