Skip to content

Lab 4: Real-World Use Cases

This page explores real-world applications and use cases for each integration pattern.

💼 Use Case 1: FAQ Bot

Best Backend: Coveo Direct API (Lab 1)

Scenario

A financial services company wants to provide instant answers to common customer questions on their website.

Requirements

  • ✅ Fast response times (<1 second)
  • ✅ High volume of queries
  • ✅ Simple question-answer format
  • ✅ No conversation context needed

Implementation

Architecture

Pattern: Direct Coveo API integration

Components: UI → API Gateway → Lambda → Coveo API

Response Time: ~200ms

Example Questions

What is FDIC insurance?
What are your business hours?
How do I reset my password?
What are current mortgage rates?

Benefits

  • ⚡ Speed: Sub-second responses
  • 📈 Scale: Handles millions of queries
  • 🔧 Simple: Easy to implement and maintain

Metrics

Metric Target Actual
Response Time <1s ~200ms
Accuracy >90% ~95%
Deflection Rate 30% 35%

💬 Use Case 2: Customer Support Chat

Best Backend: Bedrock Agent (Lab 2)

Scenario

A bank wants to provide conversational support for customers with account questions and issues.

Requirements

  • ✅ Multi-turn conversations
  • ✅ Context retention within session
  • ✅ Natural language understanding
  • ✅ Grounded responses with sources
  • ✅ Reasonable response times (2-5s)

Implementation

Architecture

Pattern: Bedrock Agent with Coveo tool

Components: UI → Lambda → Bedrock Agent → Tool → Coveo API

Response Time: ~2-3s

Example Conversation

Turn 1:

I found errors in my credit report

Turn 2:

How do I dispute them?

Turn 3:

What's the timeline for resolution?

Turn 4:

Can you create a checklist for me?

Benefits

  • 💬 Conversational: Natural multi-turn interactions
  • 🧠 Memory: Maintains context within session
  • 🎯 Grounded: Responses based on authoritative sources
  • 📊 Observable: Traces show decision-making

Metrics

Metric Target Actual
Response Time <5s ~2-3s
Deflection Rate 40% 45%
User Satisfaction >4.0/5 4.3/5
Resolution Rate 60% 65%

🎓 Use Case 3: Financial Advisory

Best Backend: AgentCore + MCP (Lab 3)

Scenario

A wealth management firm wants to provide personalized financial advice with long-term client relationships.

Requirements

  • ✅ Multi-turn conversations
  • ✅ Cross-session memory
  • ✅ Multiple tool orchestration
  • ✅ Comprehensive analysis
  • ✅ Long-term relationship building

Implementation

Architecture

Pattern: AgentCore Runtime with MCP Server

Components: UI → Lambda → Agent Runtime → MCP Server → Multiple Tools → Coveo APIs

Response Time: ~3-5s

Example Multi-Session Journey

Session 1: Initial Consultation 

Turn 1: "I want to plan for retirement"
Turn 2: "I'm 45 years old with $200k saved"
Turn 3: "I prefer moderate risk"
Turn 4: "What should I do?"

Session 2: Follow-up (Next Week) 

Turn 1: "What did we discuss last time?"
Turn 2: "I've decided to be more aggressive"
Turn 3: "Show me updated recommendations"

Session 3: Progress Review (Next Month) 

Turn 1: "How am I doing on my retirement plan?"
Turn 2: "Should I adjust anything?"
Turn 3: "What about tax implications?"

Benefits

  • 🔧 Multi-Tool: Comprehensive analysis using multiple tools
  • 🧠 Cross-Session: Remembers across visits
  • 📊 Observable: Detailed logs and traces
  • 🎯 Personalized: Tailored to individual needs

Metrics

Metric Target Actual
Response Time <8s ~3-5s
Client Satisfaction >4.5/5 4.7/5
Engagement Rate 70% 75%
Retention Rate 80% 85%

📊 Use Case Comparison

Quick Reference

Use Case Backend Memory Tools Response Time Best For
FAQ Bot Coveo None N/A ~200ms High volume, simple queries
Support Chat Bedrock Agent + Coveo Cross-session 1 ~2-3s Support conversations
Advisory AgentCore + Coveo MCP Cross-session 3+ ~3-5s Consultations, relationships
Knowledge Portal Coveo None N/A ~200ms Search and discovery
Troubleshooting Bedrock Agent + Coveo Cross-session 1 ~2-3s Guided problem solving
Research Assistant AgentCore + Coveo MCP Cross-session 3+ ~3-5s Complex research

🏢 Industry-Specific Use Cases

Financial Services

🏦 Retail Banking

Backend: Bedrock Agent + Coveo

Use Case: Account support, transaction inquiries, product information

Why: Multi-turn conversations with cross-session memory for ongoing support

💼 Wealth Management

Backend: AgentCore + Coveo MCP

Use Case: Investment advisory, portfolio management, financial planning

Why: Cross-session memory for long-term client relationships

📚 Financial Education

Backend: Coveo Direct

Use Case: Financial literacy content, educational resources

Why: Fast access to educational content without conversation needs

Healthcare

🏥 Patient Portal

Backend: Coveo Direct

Use Case: Medical information lookup, appointment scheduling

Why: Quick access to information without complex conversations

💊 Symptom Checker

Backend: Bedrock Agent + Coveo

Use Case: Interactive symptom assessment with follow-up questions

Why: Multi-turn conversation for comprehensive assessment

E-Commerce

🛍️ Product Search

Backend: Coveo Direct

Use Case: Product discovery, filtering, recommendations

Why: Fast search with faceted navigation

🤝 Shopping Assistant

Backend: Bedrock Agent + Coveo

Use Case: Guided shopping, product comparisons, recommendations

Why: Conversational product discovery with context

👤 Personal Shopper

Backend: AgentCore + Coveo MCP

Use Case: Long-term style preferences, seasonal recommendations

Why: Cross-session memory for personalized experience

💡 Implementation Considerations

Performance Considerations

Backend Latency Throughput Scalability
Coveo Lowest Highest Excellent
Bedrock Agent + Coveo Medium High Very Good
AgentCore + Coveo MCP Higher Medium Good

Complexity Considerations

Backend Setup Maintenance Extensibility
Coveo Simple Easy Limited
Bedrock Agent + Coveo Moderate Moderate Good
AgentCore + Coveo MCP Complex Moderate Excellent

🚀 Getting Started with Your Use Case

Step 1: Identify Requirements

Ask yourself:

  • Do users need multi-turn conversations?
  • Is cross-session memory valuable?
  • How complex are the queries?
  • What's the expected volume?

Step 2: Choose Backend

Use the decision framework:

  • Simple FAQ → Coveo Direct
  • Support Chat → Bedrock Agent + Coveo
  • Consultation → AgentCore + Coveo MCP

Step 3: Prototype

Start with the workshop code:

  • Clone the repository
  • Configure with your Coveo organization
  • Deploy to AWS
  • Test with your content

Step 4: Optimize

Based on testing:

  • Adjust memory settings
  • Tune system prompts
  • Add custom tools

📈 Case Deflection Value

Example Metrics:

  • Deflection rate: 40%
  • Monthly support volume: 10,000 tickets
  • Deflected tickets: 4,000 per month

Implementation Timeline

Phase Coveo Direct API Bedrock Agent with Coveo Bedrock AgentCore with Coveo MCP
Setup 1 week 2 weeks 3 weeks
Maintenance Low Medium Medium

💡 Best Practices by Use Case

For FAQ Bots (Coveo Direct)

  1. Optimize for Speed: Cache common queries
  2. Rich Content: Ensure comprehensive knowledge base
  3. Clear Sources: Always show authoritative citations
  4. Fallback: Provide escalation path to human support

For Support Chat (Bedrock Agent + Coveo)

  1. Clear Instructions: Well-defined system prompts
  2. Memory Management: Appropriate session timeouts
  3. Tool Design: Single, focused tool for grounding
  4. Escalation: Know when to transfer to human

For Advisory (AgentCore + Coveo MCP)

  1. Multiple Tools: Provide diverse capabilities
  2. Cross-Session Memory: Enable long-term relationships
  3. Observability: Monitor tool usage and performance
  4. Personalization: Leverage memory for tailored advice

🎯 Next Steps for Your Implementation

1. Define Your Use Case

  • What problem are you solving?
  • Who are your users?
  • What's the expected volume?
  • What's your budget?

2. Choose Your Backend

  • Use the decision framework
  • Consider your requirements
  • Evaluate trade-offs
  • Start with simplest solution

3. Prototype

  • Use workshop code as starting point
  • Configure with your content
  • Test with real users
  • Gather feedback

4. Iterate

  • Optimize based on usage
  • Add features as needed
  • Monitor performance
  • Improve continuously

📚 Additional Resources

Coveo Resources

Workshop Resources

AWS Resources

🎉 Workshop Complete!

Congratulations on completing all 4 labs! You now have:

  • ✅ Hands-on experience with three integration patterns
  • ✅ Understanding of when to use each approach
  • ✅ Knowledge of memory and conversation capabilities
  • ✅ Real-world use case examples
  • ✅ Implementation guidance for your own projects

Ready to Build Your Solution?

Use the workshop code as your starting point

Questions? Contact your instructor or explore the resources section.

📞 Support and Next Steps

Get Help

  • Workshop Questions: Ask your instructor
  • Technical Issues: Check troubleshooting guides
  • Implementation Help: Contact Coveo or AWS support

Continue Learning

  • Explore the code repository
  • Review architecture diagrams
  • Read additional documentation
  • Join community forums

Stay Connected

  • Subscribe to Coveo blog
  • Join user communities
  • Attend future workshops

Thank you for participating in the Coveo + AWS Bedrock Workshop!