E-commerce Orchestration Skill

Overview

This skill demonstrates Pattern 2: Multi-MCP Orchestration by coordinating between two MCP servers:

1. •task-tracker: Manages order/return tasks and workflows
2. •business-rules: Provides e-commerce policies (return windows, shipping costs, discounts)

When This Skill Activates

Claude automatically uses this skill when you mention:

Return Processing:

• •Processing/handling a return request
• •Checking return eligibility or policies
• •Customer wants to return an item
• •Return evaluation or assessment
• •Refund calculations or decisions

Order Processing:

• •Creating or processing an order
• •Applying discounts or loyalty benefits
• •Calculating shipping costs
• •Order fulfillment
• •New customer orders or bulk orders

Policy Inquiries:

• •Shipping costs for an order
• •Return windows or policies
• •Discount eligibility
• •Restocking fees
• •Business rules or policies

Multi-Server Workflows

Return Request Workflow

When processing a customer return:

Orchestration Steps:

1. •Create return task (task-tracker: create_task)
   • •Title: "Return: [Item] - [Price/Details]"
   • •Status: "pending"
   • •Include item category, purchase date, condition in description
2. •Check return policy (business-rules: check_return_policy)
   • •Parameters: category (clothing/electronics/books/food), days_since_purchase, opened (true/false)
3. •Evaluate eligibility based on policy result
   • •If eligible: calculate refund amount (original_price - restocking_fee if applied)
   • •If ineligible: note reason (outside return window, condition issues, etc.)
4. •Update task (task-tracker: update_task)
   • •Add policy decision to task description
   • •Include refund method and amount
   • •Status: "in_progress" (ready for fulfillment)
5. •Route to fulfillment based on eligibility status

Example: "Process a return for a laptop purchased 10 days ago"

• •Step 1: Creates task "Return: Laptop - Opened - 10 days"
• •Step 2: Checks policy: electronics = 14 days, opened = 15% fee
• •Step 3: Evaluates: Eligible (within 14-day window), refund = original × 0.85
• •Step 4: Updates task: "✓ ELIGIBLE - 15% restocking fee applies"
• •Step 5: Ready for fulfillment team to process

Order Processing Workflow

When creating a new order:

Orchestration Steps:

1. •Calculate discounts (business-rules: calculate_discount)
   • •Parameters: customer_status (new/existing), loyalty_tier (bronze/silver/gold), num_items
   • •Result: discount percentage to apply
2. •Calculate shipping (business-rules: calculate_shipping_cost)
   • •Parameters: order_total (after discount), shipping_type (standard/expedited/express)
   • •Result: shipping cost for the selected method
3. •Create order task (task-tracker: create_task)
   • •Title: "Order fulfillment - [Customer] - $[Total]"
   • •Status: "pending"
   • •Include itemized breakdown in description
4. •Update task (task-tracker: update_task) with final pricing
   • •Subtotal, discount amount, shipping cost, estimated tax, final total
   • •Include delivery timeline based on shipping type
5. •Route to fulfillment center based on order size/priority

Example: "Create an order for a new customer buying 12 items totaling $85"

• •Step 1: Calculates discounts: 10% new customer + 10% bulk (capped at 25%) = $21.25 discount
• •Step 2: Calculates shipping: Free standard (order $63.75 > $50)
• •Step 3: Creates task "Order fulfillment - New Customer - $63.75"
• •Step 4: Updates task with breakdown: Subtotal $85 - Discount $21.25 - Shipping $0 = Total $63.75 + tax
• •Step 5: Routes to fulfillment for processing

Complex Scenario: Return Evaluation

Scenario: "Evaluate a return for 3 opened books and 1 unopened laptop purchased 20 days ago for $500 each"

Orchestration Steps:

1. •Create multi-item return task (task-tracker: create_task)
   • •Title: "Return evaluation - 4 items - 20 days"
   • •Description: List each item with category, condition, original price
2. •Check each item's policy (business-rules: check_return_policy × 4 calls)
   • •Books: category=books, days=20, opened=true
   • •Laptop: category=electronics, days=20, opened=false
3. •Aggregate results for each item
4. •Update task (task-tracker: update_task) with itemized decision
5. •Calculate total refund and route for processing

Evaluation Results:

Books (3×):

• •Step 2: books policy = 60-day window, no restocking fee
• •Result: ✓ ELIGIBLE (within 60 days), full refund = $100 each × 3 = $300

Laptop:

• •Step 2: electronics policy = 14-day window, 15% fee if opened
• •Result: ✗ OUTSIDE WINDOW (20 days > 14 days), ineligible - cannot process

Total Return: $300 only (books eligible, laptop denied)

Note: This example shows how the skill evaluates each item independently and provides itemized refund decisions.

Available Operations

From task-tracker MCP:

• •create_task - Create order/return task with metadata
• •update_task - Update task status, add notes
• •filter_tasks - Find tasks by priority, status, project
• •list_tasks - List pending/completed tasks
• •get_task_statistics - Get completion rates, metrics

From business-rules MCP:

• •check_return_policy - Validate return eligibility
• •calculate_shipping_cost - Get shipping costs by order amount
• •calculate_discount - Apply customer/order discounts
• •get_all_policies - View all business rules

Best Practices

1. •Always check rules first: Before creating tasks, validate using business-rules to provide accurate information
2. •Embed results in tasks: Include policy decisions and calculations in task descriptions for auditing
3. •Use specific categories: Use exact category names (electronics, clothing, books, food) for accurate policies
4. •Consider customer context: Loyalty tier, purchase history affect discounts and eligibility
5. •Chain operations: Discount → Shipping → Task creation creates complete order workflows
6. •Document decisions: When rules block actions, clearly state why in task notes

Example Prompts

Return Processing

• •"Process a return for clothing purchased 20 days ago, unopened"
• •"Evaluate return for opened electronics purchased 5 days ago"
• •"Check if customer can return books purchased 45 days ago"

Order Creation

• •"Create an order for a new customer buying 8 items for $65"
• •"Create an order for a gold loyalty member buying 3 items for $120"
• •"Process an order for 25 bulk items totaling $500 with standard shipping"

Policy Inquiries

• •"What's our shipping cost for a $75 order?"
• •"What discounts apply for a silver member buying 12 items?"
• •"How long can customers return clothing?"

Integration Example

User: "I need to process a return for a dress. Customer bought it 20 days ago for $45, and it's unworn."

Steps:
1. task-tracker: Create task "Return: Dress - $45 - Unworn"
2. business-rules: check_return_policy("clothing", 20, opened=false)
   → {eligible: true, days_remaining: 10, restocking_fee: 0%, refund_method: "original_payment"}
3. task-tracker: Update task with "✓ ELIGIBLE - Full refund $45 via original payment method"
4. Result: Task ready for fulfillment, customer gets full refund

Token Efficiency Note

This pattern (Pattern 2) uses 2 MCP servers, which increases token usage compared to Pattern 1:

• •Pattern 1 (single server): ~600-1000 tokens
• •Pattern 2 (multi-server): ~1000-1500 tokens

The additional tokens are worth it because:

• •Business rules are independently versioned and managed
• •Rule changes don't require server restarts
• •Clear separation of concerns (tasks vs. policies)
• •Demonstrates real-world orchestration patterns

Implementation Requirements

This skill requires:

• •task-tracker MCP server - For creating and updating return/order tasks
• •business-rules MCP server - For checking policies and calculating costs/discounts

When the skill activates, it orchestrates calls to both MCP servers in sequence:

1. •Create/query task-tracker to initialize tasks
2. •Call business-rules to validate against policies
3. •Update task-tracker with results and decisions
4. •Route to appropriate fulfillment/processing workflow

Both MCP servers must be registered and running for this skill to function properly.

See Also

• •PATTERNS_CATALOG.md - Pattern 2 detailed documentation
• •PATTERN_2_IMPLEMENTATION.md - Implementation details