Beyond Auto-Replies: Building an AI-Powered E-commerce Support system

Ever received an automated customer support email so useless, you wondered if it was secretly written by a random word generator? "We value your inquiry about your missing order. Have you tried turning your mailbox off and on again?". Hold onto your sanity, because I've discovered a customer service revolution that makes those robo-responses look like cave paintings: say hello to AI Agents and the Multi-Agent Orchestrator framework.

In this article, I'm fixing the messy world of online store help, where shoppers get angry quicker than people leaving an email list after a bad ad. I'll show you how to build an AI-powered support system so effective, it makes those "Your call is important to us" messages sound sincere 🤩.

We'll explore how the Multi-Agent Orchestrator and Project Lakechain team up to create the superhero of customer support - no cape or secret identity required. Ready to rescue customers from the clutches of confusion? Let's swoop in!

Our intelligent email processing system leverages Amazon SQS, Lakechain's EmailTextProcessor, and the Multi-Agent Orchestrator framework to efficiently handle customer inquiries. Here's how it works:

Incoming emails are ingested into an SQS queue
Lakechain's EmailTextProcessor extracts the text and forwards it to another SQS queue
A Lambda function processes this queue using the Multi-Agent Orchestrator, which:
- Determines the most appropriate AI Agent for each query
- Generates a response using the chosen agent
The response is then sent to a final SQS queue for further processing or direct customer communication

Before we dive into the technical implementation, let's visualize the high-level workflow of our intelligent email processing system:

Image not found

This diagram outlines the journey of customer emails through our AI-powered support system:

Inbound emails first land in a queue for raw emails.
The Email Content Extraction step processes these raw emails, extracting the relevant text.
Processed emails are then placed in another queue, ready for AI analysis.
The Response Generation phase is where our Multi-Agent Orchestrator shines, determining the most appropriate AI agent to handle the query and generating a response.
Finally, the generated responses are queued for outbound delivery to customers.

This streamlined architecture ensures efficient email processing, intelligent query routing, and prompt customer response generation.

The Cast of AI Agents

Based on the kinds of emails we could get, here's our help team:

📦 Order Management Agent: Handles everything related to orders, shipments, and returns.
🏷️ Product Information Agent: Answers questions about product specifications, compatibility, and availability.
💁 Customer Service Agent: For all those general inquiries and account stuff. It's basically a digital version of that super-helpful store clerk we all wish we had.
👤 Human Agent: Handles complex issues that require human intervention.
🤖👀 AI with Human Verification Agent: Generates AI responses for high-priority inquiries, which are then verified by a human.

Orchestrating our AI Team

A. Setting Up Your Project:

Create a new project directory and navigate into it

1
mkdir ecommerce-support-ai && cd ecommerce-support-ai

B. Initialize a Node.js project and install necessary dependencies:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# Initialize npm project
npm init -y

# Install TypeScript and Node.js types as development dependencies
npm install typescript @types/node --save-dev

# Install multi-agent orchestrator and AWS Bedrock agent runtime
npm install multi-agent-orchestrator
npm install @aws-sdk/client-bedrock-agent-runtime

# Install additional dependencies without specifying versions
npm install \
    "@project-lakechain/bedrock-text-processors" \
    "@project-lakechain/core" \
    "@project-lakechain/email-text-processor" \
    "@project-lakechain/opensearch-domain" \
    "@project-lakechain/pandoc-text-converter" \
    "@project-lakechain/pdf-text-converter" \
    "@project-lakechain/recursive-character-text-splitter" \
    "@project-lakechain/s3-event-trigger" \
    "@project-lakechain/sqs-storage-connector"

C. Create a src directory and the agents.ts file:

1
mkdir src && touch src/agents.ts

Step 1: Create mock functions:

Create a new file named agents.ts in your project directory:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import {
  MultiAgentOrchestrator,
  BedrockLLMAgent,
  BedrockLLMAgentOptions,
  AmazonBedrockAgent,
  AmazonBedrockAgentOptions,
  AgentResponse,
  AmazonKnowledgeBasesRetriever,
  Agent,
  ChainAgent,
  ChainAgentOptions,
  ConversationMessage,
  ParticipantRole
} from 'multi-agent-orchestrator';
import { BedrockAgentRuntimeClient } from "@aws-sdk/client-bedrock-agent-runtime";

// Mock databases
const orderDb: Record<string, any> = {
  "12345": { status: "Shipped", items: ["Widget A", "Gadget B"], total: 150.00 },
  "67890": { status: "Processing", items: ["Gizmo C"], total: 75.50 },
};

const shipmentDb: Record<string, any> = {
  "12345": { carrier: "FastShip", trackingNumber: "FS123456789", status: "In Transit" },
};

const productDb: Record<string, any> = {
  "Widget A": { price: 50.00, stock: 100, description: "A fantastic widget" },
  "Gadget B": { price: 100.00, stock: 50, description: "An amazing gadget" },
  "Gizmo C": { price: 75.50, stock: 25, description: "A wonderful gizmo" },
};

// Mock functions for tools
const orderLookup = (orderId: string): any => orderDb[orderId] || null;
const shipmentTracker = (orderId: string): any => shipmentDb[orderId] || null;
const returnProcessor = (orderId: string): string => `Return initiated for order ${orderId}`;

These imports and mock databases set up the foundation for our system. In a real-world scenario, you should replace these mock databases with actual database connections.

Step 2: Order Management Agent Setup:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
const orderManagementToolConfig = [
  {
    toolSpec: {
      name: "OrderLookup",
      description: "Retrieve order details from the database",
      inputSchema: {
        json: {
          type: "object",
          properties: {
            orderId: { type: "string", description: "The order ID to look up" }
          },
          required: ["orderId"]
        }
      }
    }
  },
  {
    toolSpec: {
      name: "ShipmentTracker",
      description: "Get real-time shipping information",
      inputSchema: {
        json: {
          type: "object",
          properties: {
            orderId: { type: "string", description: "The order ID to track" }
          },
          required: ["orderId"]
        }
      }
    }
  },
  {
    toolSpec: {
      name: "ReturnProcessor",
      description: "Initiate and manage return requests",
      inputSchema: {
        json: {
          type: "object",
          properties: {
            orderId: { type: "string", description: "The order ID for the return" }
          },
          required: ["orderId"]
        }
      }
    }
  }
];

export async function orderManagementToolHandler(response: ConversationMessage, conversation: ConversationMessage[]) {
  const responseContentBlocks = response.content as any[];
  let toolResults: any = [];

  if (!responseContentBlocks) {
    throw new Error("No content blocks in response");
  }

  for (const contentBlock of responseContentBlocks) {
    if ("toolUse" in contentBlock) {
      const toolUseBlock = contentBlock.toolUse;
      const toolUseName = toolUseBlock.name;
      let result;

      switch (toolUseName) {
        case "OrderLookup":
          result = orderLookup(toolUseBlock.input.orderId);
          break;
        case "ShipmentTracker":
          result = shipmentTracker(toolUseBlock.input.orderId);
          break;
        case "ReturnProcessor":
          result = returnProcessor(toolUseBlock.input.orderId);
          break;
      }

      if (result) {
        toolResults.push({
          "toolResult": {
            "toolUseId": toolUseBlock.toolUseId,
            "content": [{ json: { result } }],
          }
        });
      }
    }
  }

  const message: ConversationMessage = { role: ParticipantRole.USER, content: toolResults };
  conversation.push(message);
}

const orderManagementAgent = new BedrockLLMAgent({
  name: "Order Management Agent",
  description: "Handles order-related inquiries including order status, shipment tracking, returns, and refunds. Uses order database and shipment tracking tools.",
  modelId: "anthropic.claude-3-sonnet-20240229-v1:0",
  toolConfig: {
    useToolHandler: orderManagementToolHandler,
    tool: orderManagementToolConfig,
    toolMaxRecursions: 5
  },
  saveChat: false
} as BedrockLLMAgentOptions);

In this step, we create an Order Management Agent using the BedrockLLMAgent, which combines Amazon Bedrock's powerful language understanding capabilities with the Converse API. This agent is designed to handle complex order-related inquiries and perform actions like order lookup, shipment tracking, and return processing.

The key feature of this setup is the definition and implementation of tools that the LLM can call to execute specific tasks based on customer requests. We've defined three tools:

OrderLookup: Retrieves order details from the database
ShipmentTracker: Gets real-time shipping information
ReturnProcessor: Initiates and manages return requests

Here's how the tools are defined and implemented:

Tool Definition: We define the tools in the orderManagementToolConfig array. Each tool has a name, description, and an input schema that specifies what information is needed to use the tool.
Tool Implementation: The orderManagementToolHandler function contains the actual implementation of these tools. When the LLM determines it needs to use a tool, it calls this handler. The handler then:
- Identifies which tool is being called
- Executes the corresponding function (e.g., orderLookup, shipmentTracker, or returnProcessor)
- Formats the result and adds it to the conversation
LLM Integration: The BedrockLLMAgent is configured with these tools using the toolConfig property. This allows the LLM to:
- Understand what tools are available
- Decide when to use a tool based on the customer's request
- Call the appropriate tool and receive the results

This setup enables the Order Management Agent to seamlessly combine natural language understanding with specific order-related actions. For example, when a customer asks about their order status, the LLM can recognize the need for order information, use the OrderLookup tool to fetch the details, and then formulate a natural language response based on the retrieved data.

By defining these tools and their implementation, we're giving the LLM the ability to perform concrete actions in response to customer queries, making the agent much more capable and useful in handling real-world order management scenarios.

3: Customer Service Agent Setup:

1
2
3
4
5
6
7
const customerServiceAgent = new AmazonBedrockAgent({
  name: "Customer Service Agent",
  description: "Handles general customer inquiries, account-related questions, and non-technical support requests. Uses comprehensive customer service knowledge base.",
  agentId: "your-agent-id",
  agentAliasId: "your-agent-alias-id",
  saveChat: false
} as AmazonBedrockAgentOptions);

Important Note: The AmazonBedrockAgent requires a pre-existing Bedrock Agent with an attached knowledge base. This agent should be created and configured in the AWS Bedrock console before using it in this code. The knowledge base should contain information relevant to customer service, such as:

Frequently Asked Questions (FAQs)
Company policies (returns, shipping, privacy, etc.)
Account management procedures
Troubleshooting guides for common issues

Replace "your-agent-id" and "your-agent-alias-id" with the actual IDs of your Bedrock Agent.

4. Product Information Agent Setup:

1
2
3
4
5
6
7
8
9
10
11
12
const productInfoRetriever = new AmazonKnowledgeBasesRetriever(
  new BedrockAgentRuntimeClient({}),
  { knowledgeBaseId: "your-product-kb-id" }
);

const productInfoAgent = new BedrockLLMAgent({
  name: "Product Information Agent",
  description: "Provides detailed product information, answers questions about specifications, compatibility, and availability.",
  modelId: "anthropic.claude-3-haiku-20240307-v1:0",
  retriever: productInfoRetriever,
  saveChat: false
} as BedrockLLMAgentOptions);

We chose the BedrockLLMAgent specifically the Claude 3 Haiku model. This setup offers several advantages:

Knowledge Integration: This setup implements a RAG. The AmazonKnowledgeBasesRetriever connects to a vector database containing contextual product data. When a query is received, relevant information is retrieved from this database and fed into the language model, allowing it to provide responses based on the most up-to-date and specific product information.
Stateless Interactions: Setting saveChat to false optimizes the agent for independent queries, as product information requests typically don't require context from previous interactions.

This configuration creates a Product Information Agent capable of handling a wide range of product-related inquiries. By using RAG, it ensures that responses are drawing from the latest data in the vector database.

5. Human Agent Setup:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class HumanAgent extends Agent {
  async processRequest(inputText: string, userId: string, sessionId: string, chatHistory: ConversationMessage[]): Promise<ConversationMessage> {
    console.log(`Human agent received request: ${inputText}`);
    const humanResponse = await this.simulateHumanResponse(inputText);
    return {
      role: ParticipantRole.ASSISTANT,
      content: [{ text: humanResponse }]
    };
  }

  private async simulateHumanResponse(input: string): Promise<string> {
    console.log(`Sending email to SQS queue: "${input}"`);
    return `Your request has been received and will be processed by our customer service team. We'll get back to you as soon as possible.`;
  }
}

const humanAgent = new HumanAgent({
  name: "Human Agent",
  description: "Handles complex inquiries, complaints, or sensitive issues requiring human expertise.",
  saveChat: false
});

In this setup, we create a Human Agent by extending the base Agent class. This agent is designed to handle specific domains or topics that are beyond the capabilities of our AI models. The key idea here is that we've defined a "domain" of queries that should be directly routed to human operators, rather than being processed by an LLM.

This Human Agent serves several purposes:

Handling Complex Issues: For topics that require nuanced understanding, emotional intelligence the Human Agent ensures these queries are directed to actual human operators.
Sensitive Matters: Complaints, legal issues, or other sensitive topics that an LLM might not handle appropriately are routed through this agent.
Compliance: For industries with strict regulations or where human oversight is mandatory, this agent ensures that certain types of inquiries are always handled by authorized personnel.

In a real-world implementation, the simulateHumanResponse method would likely integrate with a ticketing system. This could involve placing the query in a queue for human review, sending an email to a relevant department, or triggering an alert in a customer service dashboard.

5. AI with Human verification Agent Setup:

1
2
3
4
5
6
7
8
9
10
11
12
13
const aiWithHumanVerificationAgent = new ChainAgent({
  name: "AI with Human Verification Agent",
  description: "Handles high-priority or sensitive customer inquiries by generating AI responses and having them verified by a human before sending.",
  agents: [
    customerServiceAgent,
    new HumanAgent({
      name: "Human Verifier",
      description: "Verifies and potentially modifies AI-generated responses",
      saveChat: false
    })
  ],
  saveChat: false
} as ChainAgentOptions);

This setup demonstrates how to combine AI efficiency with human oversight for handling sensitive or complex customer inquiries. In this approach, the LLM (customerServiceAgent) is utilized to generate an initial response. This AI-generated response serves as a helpful starting point, potentially saving time and ensuring consistency.

However, recognizing that some domains require absolute accuracy or may involve nuances that AI might miss, a human reviewer then steps in. The human verifier checks the AI-generated response for accuracy, appropriateness, and completeness.

This hybrid approach leverages the strengths of both AI and human expertise:

The LLM quickly generates a draft response, providing efficiency and consistency.
A human expert reviews and refines the response, ensuring accuracy and adding nuance where necessary.

By using a ChainAgent**** to combine these steps, we create a workflow that balances speed with precision, particularly valuable in high-stakes communications or industries with strict regulatory requirements.

6. Add agents to orchestrator:

1
2
3
4
5
6
// Create and export the orchestrator
export const orchestrator = new MultiAgentOrchestrator();
orchestrator.addAgent(orderManagementAgent);
orchestrator.addAgent(productInfoAgent);
orchestrator.addAgent(humanAgent);
orchestrator.addAgent(aiWithHumanVerificationAgent);

In this final step, we create an instance of the MultiAgentOrchestrator and add all the agents we've created to it. This process registers each agent with the orchestrator, allowing it to manage and coordinate their actions.

Depending on your specific use case, you can easily add more specialized agents to the orchestrator. The flexibility of this system allows you to expand and customize your agent network to meet the unique needs of your application or business domain.

A. Local usage

To test the orchestrator locally, you can create a simple script. Here's an example local-test.ts:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import { orchestrator } from './agents';

async function testOrchestrator() {
  const testEmails = [
    { text: "What's the status of my order #12345?", userId: "user1", sessionId: "session1" },
    { text: "I need more information about Widget A", userId: "user2", sessionId: "session2" },
    { text: "How do I change my account password?", userId: "user3", sessionId: "session3" },
    { text: "I have a complex issue with my recent purchase", userId: "user4", sessionId: "session4" },
    { text: "Is my personal information secure on your website?", userId: "user5", sessionId: "session5" }
  ];

  for (const email of testEmails) {
    console.log(`Processing email: "${email.text}"`);
    const response = await orchestrator.routeRequest(email.text, email.userId, email.sessionId);
    console.log(`Response from ${response.metadata.agentName}:`);
    console.log(response.output);
    console.log('---');
  }
}

testOrchestrator().catch(console.error);

Run this script using ts-node local-test.ts to see how the orchestrator handles different types of inquiries locally.

B. Cloud Deployment with CDK

I've shown you how to process emails locally using our multi-agent orchestrator, but in a real-world scenario, you'll likely want to integrate this system into a more robust, scalable architecture. Imagine a workflow where incoming customer emails are sent to a queue for processing, and the responses are then placed in another queue to be sent back to customers.

This is where Project Lakechain comes in handy. Project Lakechain is a powerful tool that allows us to quickly set up and deploy complex data processing pipelines on AWS. In this section, I'll show you how to use Project Lakechain components to create an end-to-end email processing system that leverages our multi-agent orchestrator.

Let's set up the infrastructure using AWS CDK:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
import { EmailTextProcessor } from "@project-lakechain/email-text-processor";
import { CacheStorage } from "@project-lakechain/core";
import { S3EventTrigger } from "@project-lakechain/s3-event-trigger";
import { SqsStorageConnector } from "@project-lakechain/sqs-storage-connector";
import path from "path";

import {
  aws_lambda as lambda,
  aws_sqs as sqs,
  aws_s3 as s3,
  aws_lambda_nodejs as nodejs,
  aws_iam as iam,
} from "aws-cdk-lib";

import * as cdk from "aws-cdk-lib";
import { Construct } from "constructs";

export class TestCdkArticleEmailsStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    const bucket = new s3.Bucket(this, "Bucket", {});

    const cache = new CacheStorage(this, "Cache");
    const processedEmailsQueue = new sqs.Queue(this, "ProcessedEmailsQueue");
    const responseQueue = new sqs.Queue(this, "ResponseQueue");

    // Create the S3 event trigger.
    const trigger = new S3EventTrigger.Builder()
      .withScope(this)
      .withIdentifier("Trigger")
      .withCacheStorage(cache)
      .withBucket(bucket)
      .build();

    // Create the email text processor
    const emailProcessor = new EmailTextProcessor.Builder()
      .withScope(this)
      .withIdentifier("EmailProcessor")
      .withCacheStorage(cache)
      .withSource(trigger)
      .withOutputFormat("text")
      .withIncludeAttachments(false)
      .build();

    // Create the SQS storage connector for processed emails
    const processedEmailsConnector = new SqsStorageConnector.Builder()
      .withScope(this)
      .withIdentifier("ProcessedEmailsConnector")
      .withCacheStorage(cache)
      .withSource(emailProcessor)
      .withDestinationQueue(processedEmailsQueue)
      .build();

    const orchestratorLambda = new nodejs.NodejsFunction(
      this,
      "OrchestratorLambda",
      {
        entry: path.join("lambda", "index.ts"),
        handler: "handler",
        runtime: lambda.Runtime.NODEJS_20_X,
        environment: {
          RESPONSE_QUEUE_URL: responseQueue.queueUrl,
        },
        memorySize: 2048,
        timeout: cdk.Duration.minutes(10),
      }
    );

    orchestratorLambda.addToRolePolicy(
      new iam.PolicyStatement({
        effect: iam.Effect.ALLOW,
        actions: ["bedrock:InvokeModel"],
        resources: ["*"],
      })
    );

    // Grant Lambda permissions to read from processedEmailsQueue and write to responseQueue
    processedEmailsQueue.grantConsumeMessages(orchestratorLambda);
    responseQueue.grantSendMessages(orchestratorLambda);
    processedEmailsConnector.grantReadProcessedDocuments(orchestratorLambda);
    emailProcessor.grantReadProcessedDocuments(orchestratorLambda);

    // Set up event source mapping for Lambda
    new lambda.EventSourceMapping(this, "OrchestratorEventSourceMapping", {
      target: orchestratorLambda,
      batchSize: 10,
      eventSourceArn: processedEmailsQueue.queueArn,
    });
  }
}

Implementing the Lambda Function

Here's an example of how the Lambda function might be implemented:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
import { SQSEvent } from "aws-lambda";
import { SQSClient, SendMessageCommand } from "@aws-sdk/client-sqs";
import { orchestrator } from "./agents";
import { S3Client, GetObjectCommand } from "@aws-sdk/client-s3";
import { Readable } from "stream";

const sqs = new SQSClient({});
const s3 = new S3Client({});

export const handler = async (event: SQSEvent): Promise<void> => {
  for (const record of event.Records) {
    const eventData = JSON.parse(record.body);
    console.log("Event Data: ", JSON.stringify(eventData, null, 2));

    const documentUrl = eventData.data.document.url;
    const subject = eventData.data.metadata.title;

    // Extract the S3 bucket and key from the URL
    const { bucketName, objectKey } = parseS3Url(documentUrl);
    console.log(`Bucket: ${bucketName}, Key: ${objectKey}`);

    try {
      // Retrieve the document from S3
      const objectContent = await getDocumentFromS3(bucketName, objectKey);
      console.log("Document Content:\n", objectContent);
      const response = await orchestrator.routeRequest(
        objectContent,
        "userId",
        "sessionId"
      );

      // Print the subject and text before sending the message
      console.log("Subject:", `Re: ${subject}`);
      console.log("Text:", response.output);

      const sendMessageCommand = new SendMessageCommand({
        QueueUrl: process.env.RESPONSE_QUEUE_URL!,
        MessageBody: JSON.stringify({
          subject: `Re: ${subject}`,
          text: response.output,
          handlingAgent: response.metadata.agentName,
        }),
      });

      await sqs.send(sendMessageCommand);
    } catch (error) {
      console.error("Error retrieving document from S3:", error);
    }
  }
};

// Helper function to parse S3 URL
const parseS3Url = (url: string): { bucketName: string; objectKey: string } => {
  const match = url.match(/^s3:\/\/([^\/]+)\/(.+)$/);
  if (!match) {
    throw new Error(`Invalid S3 URL: ${url}`);
  }
  return {
    bucketName: match[1],
    objectKey: match[2],
  };
};

// Helper function to retrieve the document from S3
const getDocumentFromS3 = async (
  bucketName: string,
  key: string
): Promise<string> => {
  const command = new GetObjectCommand({
    Bucket: bucketName,
    Key: key,
  });

  const response = await s3.send(command);

  const streamToString = (stream: Readable): Promise<string> =>
    new Promise((resolve, reject) => {
      const chunks: Uint8Array[] = [];
      stream.on("data", (chunk) => chunks.push(chunk));
      stream.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
      stream.on("error", reject);
    });

  return streamToString(response.Body as Readable);
};

💻 The full CDK code for this implementation is available on my gist for easy reference and use. This gist provides a complete, runnable example of the AI-powered customer support system we've discussed.

This Lambda function reads messages from the SQS queue, processes them using the Multi-Agent Orchestrator, and sends the responses to the output queue.

Creating this system was so straightforward, I had more trouble choosing my lunch than setting up these AI Agents!

After diving deep into the implementation details, let me show you the full picture of what I've built. Here's a diagram that captures all the components of our AI-powered customer support system:

Image not found

Testing this system is remarkably simple: just send raw emails to the entry SQS queue and observe the responses in the output queue. This allows you to easily verify the end-to-end flow of your AI-powered customer support system.

Test Scenarios and Results

During my testing phase, I sent various sample emails to the system and observed the responses. Here are some example scenarios with their inputs and outputs:

Scenario 1: Order Status Inquiry

Sample Input Email:

Image not found

System Response:

Image not found

Scenario 2: Return Request

Sample Input Email

Image not found

System Response:

Image not found

These examples demonstrate how our multi-agent system handles a variety of customer inquiries. Each query starts as a raw email in the first SQS queue, is processed by the EmailTextProcessor, routed to the most appropriate agent by the Multi-Agent Orchestrator, and finally output as a structured response in the final SQS queue. The handlingAgent field in the output shows which specialized agent was selected to handle the specific inquiry.

Conclusion

Image not found

By leveraging the Multi-Agent Orchestrator framework and Project Lakechain, I've not only solved the customer support headaches but also unlocked a new level of efficiency and scalability for e-commerce businesses. This intelligent system, with its specialized AI Agents, can handle everything from simple order inquiries to complex customer issues, all while maintaining that crucial human touch when needed.

Now, I'm curious to hear from you. How do you see these AI Agents and the Multi-Agent Orchestrator framework transforming your business? What other innovative applications can you envision for this technology? Let me know in the comments below — who knows, your idea might be the next big revolution in AI-powered customer service!

While this example uses Typescript, the Multi-Agent Orchestrator framework is also available for Python, allowing you to implement the same functionality.

Explore more

If you enjoyed this article and want to explore more about what Multi Agent Orchestrator framework can do, check out our related piece: From 'Bonjour' to 'Boarding Pass': Multilingual AI Chatbot for Flight Reservations. This article walks you through building a global flight reservation chatbot, demonstrating how to chain AI agents for instant language processing and booking across multiple languages.

Multi Agent Orchestrator

📚 Documentation: Get comprehensive guidance and details on how to use the toolkit effectively.
🛠️ GitHub Repository: Access the source code, contribute, or browse issues and updates.
📦 NPM Repository
📦 PyPi Repository

Project Lakechain

📚 Documentation: Comprehensive guidance
🛠️ GitHub Repository: Access the source code, contribute, or browse issues and updates.

If you find these frameworks helpful, please consider giving us a star on GitHub. Also we would love to hear your thoughts, so feel free to leave a comment below. And if you have ideas for new features or improvements, don't hesitate to create a feature request on our GitHub repository.

Select your cookie preferences

Site Terms, Privacy, and more.

Beyond Auto-Replies: Building an AI-Powered E-commerce Support system

The Cast of AI Agents

Orchestrating our AI Team

Step 1: Create mock functions:

Step 2: Order Management Agent Setup:

3: Customer Service Agent Setup:

4. Product Information Agent Setup:

5. Human Agent Setup:

5. AI with Human verification Agent Setup:

6. Add agents to orchestrator:

A. Local usage

B. Cloud Deployment with CDK

Test Scenarios and Results

Scenario 1: Order Status Inquiry

Scenario 2: Return Request

Conclusion

Explore more

Multi Agent Orchestrator

Project Lakechain

Comments