Multi-turn Dialogue Assistant Based on AI Agent Session

Multi-turn Dialogue Assistant Based on AI Agent Session#

This case demonstrates how to build an intelligent dialogue assistant that supports multi-turn interaction by leveraging openYuanrong’s AI Agent Session capability. Through wait and notify mechanisms, functions can suspend execution and wait for user input during execution, thereby implementing complex interaction logic.

Scenario Description#

In traditional FaaS models, functions are typically trigger-based execution and “run-to-completion”. For multi-turn dialogue scenarios, developers usually need to manage complex context states themselves (such as Redis or databases).

openYuanrong’s AI Agent Session feature provides the following advantages:

  • Automatic State Management: Session context is automatically persisted and loaded with the session lifecycle.

  • Execution Flow Suspension: Supports suspension within functions via wait, waiting for subsequent requests from the same session to wake up.

  • Low-latency Response: Through session affinity scheduling, ensures requests from the same session are routed to the same instance, reducing cold start and state synchronization overhead.

Development Steps#

1. Enable Function Session Feature#

When registering the function, set enableAgentSession to true.

# Register using yr command line tool or REST API
curl -X POST http://{meta_service}/serverless/v1/functions \
-H "Content-Type: application/json" \
-d '{
    "name": "0@ai@dialogue-agent",
    "runtime": "java8",
    "handler": "org.example.DialogueAgent.handle",
    "enableAgentSession": true,
    "cpu": 1000,
    "memory": 1024
}'

2. Write Function Logic (Java)#

Implement a simple multi-turn Q&A logic using Java SDK.

package org.example;

import org.yuanrong.services.Context;
import org.yuanrong.services.session.Session;
import org.yuanrong.services.session.SessionService;
import com.google.gson.JsonObject;
import java.util.ArrayList;
import java.util.List;

public class DialogueAgent {
    public Object handle(Context ctx, JsonObject input) {
        SessionService sessService = ctx.getSessionService();
        Session sess = sessService.loadSession(ctx.getSessionId());

        // 1. If it's a notify request (triggered by subsequent calls), execute wake-up logic
        if (input.has("action") && "notify".equals(input.get("action").getAsString())) {
            sess.notify(input.getAsJsonObject("payload"));
            return null; // Notify request does not return results to the current trigger
        }

        // 2. Main session execution flow
        try {
            // First round
            ctx.getStream().write("Hello! I'm your AI assistant. What should I call you?\n");
            JsonObject nameInput = sess.wait(60000); // Suspend and wait for input, timeout 60s
            if (nameInput == null) return "Timeout waiting for name";
            
            String userName = nameInput.get("message").getAsString();
            
            // Update session history
            List<String> history = new ArrayList<>(sess.getHistories());
            history.add("User Name: " + userName);
            sess.setHistories(history);

            // Second round
            ctx.getStream().write(userName + ", nice to meet you! How can I help you today?\n");
            JsonObject taskInput = sess.wait(60000);
            if (taskInput == null) return "Timeout waiting for task instruction";

            String task = taskInput.get("message").getAsString();
            ctx.getStream().write("OK, processing your task: " + task + "...\n");
            
            // Simulate task processing...
            Thread.sleep(2000);
            
            ctx.getStream().write("Processing complete! Goodbye, " + userName + ".");

        } catch (Exception e) {
            ctx.getLogger().log("Error: " + e.getMessage());
        }

        return "Session Finished";
    }
}

Client Interaction Flow#

Step A: Start session and begin first round

  1. Client: Call POST /invocations (SessionID: S1)

  2. Gateway: Forward request to bound instance

  3. Function Instance: Execute business logic and enter sess.wait(), execution thread suspends

Step B: Send notification data for wake-up

  1. Client: Call POST /invocations (Same SessionID, Action: notify)

  2. Gateway: Distribute request to the same instance (session affinity)

  3. Function Instance: Execute sess.notify(payload), wake up previously suspended thread

  4. Function Instance: Return Notify operation success response to gateway

Wake-up and Final Response

  1. Function Instance: Original thread successfully wakes up, obtains data and continues processing subsequent logic

  2. Function Instance: Complete all processing logic, return final result of first round request to client

Summary#

Through AI Agent Session, developers can write multi-turn interaction logic as if writing a single-machine synchronous program, greatly simplifying the complexity of distributed context management. Combined with openYuanrong’s session affinity scheduling, the system can efficiently handle notification requests, ensuring interaction real-time performance.