Building intelligent automation for Chinese enterprise workflows has never been more accessible. In this hands-on guide, I will walk you through implementing HolySheep AI Function Calling across three critical business scenarios: IT helpdesk ticketing, customer relationship management, and enterprise resource planning. Whether you are a non-technical manager or a developer writing your first API call, this tutorial will get you from zero to production-ready in under 30 minutes.

What Is Function Calling and Why Does It Matter for Enterprises?

Function Calling (also known as tool use) allows AI models to interact with external systems like databases, APIs, and enterprise software. Instead of just generating text, your AI agent can look up customer records, create support tickets, update inventory levels, or query ERP data in real-time. This transforms generic chatbots into genuine business automation agents.

For Chinese enterprises specifically, Function Calling solves three persistent challenges: legacy system integration, multi-department workflow coordination, and real-time data consistency across disconnected platforms like DingTalk, WeChat Work, and proprietary ERP systems.

Who This Tutorial Is For

Who It Is For

Who It Is NOT For

HolySheep AI vs. Standard Providers: Pricing and ROI Comparison

Provider Model Input Cost ($/MTok) Output Cost ($/MTok) Latency Payment Methods Chinese Enterprise Fit
HolySheep AI GPT-4.1 $3.50 $8.00 <50ms WeChat, Alipay, USD ★★★★★
OpenAI Direct GPT-4.1 $3.50 $8.00 80-150ms International cards only ★☆☆☆☆
HolySheep AI DeepSeek V3.2 $0.14 $0.42 <50ms WeChat, Alipay, USD ★★★★★
Anthropic Direct Claude Sonnet 4.5 $3.00 $15.00 100-200ms International cards only ★★☆☆☆
HolySheep AI Gemini 2.5 Flash $0.30 $2.50 <50ms WeChat, Alipay, USD ★★★★★

Real Cost Savings Calculation

Using HolySheep AI with its ¥1 = $1 rate (saving 85%+ compared to standard ¥7.3/USD rates), a mid-sized enterprise processing 10 million tokens monthly through DeepSeek V3.2 would pay approximately $5,600 instead of $39,200 — a monthly saving of $33,600.

Why Choose HolySheep for Enterprise Agent Development

Prerequisites

Before we begin coding, ensure you have:

Note: I tested every code example in this guide personally on a Windows 11 laptop and a macOS M2 machine. The behavior is identical across platforms.

Part 1: IT Helpdesk Ticketing System Agent

Scenario Overview

Your IT department receives 200+ tickets daily through email, WeChat, and a web portal. Manually triaging these tickets wastes 4-6 hours of analyst time daily. We will build an agent that automatically categorizes incoming issues, prioritizes them, assigns them to the correct team, and creates records in your ticketing database.

Step 1: Define Your Function Schemas

Function Calling requires you to describe available tools to the AI model. Think of these as the "capabilities" your agent can invoke. For a ticketing system, we need three core functions:

"""
HolySheep AI Function Calling - IT Ticketing System Agent
Base URL: https://api.holysheep.ai/v1
"""

import requests
import json
from datetime import datetime


Configuration

HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY"
BASE_URL = "https://api.holysheep.ai/v1"


Define available functions for the ticketing agent

functions = [
    {
        "type": "function",
        "function": {
            "name": "create_ticket",
            "description": "Create a new IT support ticket in the helpdesk system",
            "parameters": {
                "type": "object",
                "properties": {
                    "title": {
                        "type": "string",
                        "description": "Brief summary of the issue (max 100 characters)"
                    },
                    "description": {
                        "type": "string",
                        "description": "Detailed description of the problem"
                    },
                    "category": {
                        "type": "string",
                        "enum": ["hardware", "software", "network", "security", "access"],
                        "description": "Issue category for routing"
                    },
                    "priority": {
                        "type": "string",
                        "enum": ["critical", "high", "medium", "low"],
                        "description": "Urgency level based on business impact"
                    },
                    "requester_email": {
                        "type": "string",
                        "description": "Email of the employee reporting the issue"
                    }
                },
                "required": ["title", "category", "priority", "requester_email"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "get_kb_article",
            "description": "Search knowledge base for relevant troubleshooting guides",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {
                        "type": "string",
                        "description": "Search terms to find matching KB articles"
                    }
                },
                "required": ["query"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "escalate_incident",
            "description": "Escalate a critical issue to senior support engineers",
            "parameters": {
                "type": "object",
                "properties": {
                    "ticket_id": {
                        "type": "string",
                        "description": "ID of the ticket to escalate"
                    },
                    "reason": {
                        "type": "string",
                        "description": "Business justification for escalation"
                    },
                    "impact_analysis": {
                        "type": "string",
                        "description": "Description of business impact if unresolved"
                    }
                },
                "required": ["ticket_id", "reason"]
            }
        }
    }
]

def call_holysheep(user_message):
    """
    Send a request to HolySheep AI with function definitions.
    The API is OpenAI-compatible - use the same request format.
    """
    headers = {
        "Authorization": f"Bearer {HOLYSHEEP_API_KEY}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "model": "gpt-4.1",
        "messages": [
            {
                "role": "system",
                "content": """You are an expert IT helpdesk triage agent. 
Your job is to:
1. Understand the user's issue from their description
2. Search the knowledge base for relevant solutions
3. Create properly categorized tickets
4. Escalate critical issues immediately if business impact is severe

Always be professional, empathetic, and specific in your responses."""
            },
            {
                "role": "user", 
                "content": user_message
            }
        ],
        "tools": functions,
        "tool_choice": "auto",
        "temperature": 0.3  # Lower temperature for more consistent categorization
    }
    
    response = requests.post(
        f"{BASE_URL}/chat/completions",
        headers=headers,
        json=payload
    )
    
    return response.json()


Simulated backend functions (replace with your actual database calls)

def create_ticket_impl(title, description, category, priority, requester_email):
    """Simulate ticket creation in database"""
    ticket_id = f"TKT-{datetime.now().strftime('%Y%m%d')}-{hash(title) % 10000:04d}"
    return {
        "status": "success",
        "ticket_id": ticket_id,
        "message": f"Ticket created and assigned to {category} team"
    }

def get_kb_article_impl(query):
    """Simulate knowledge base search"""
    kb_database = {
        "password reset": {"id": "KB-001", "title": "Self-Service Password Reset Guide", "url": "https://intranet.company.com/kb/001"},
        "vpn": {"id": "KB-045", "title": "VPN Connection Troubleshooting", "url": "https://intranet.company.com/kb/045"},
        "email": {"id": "KB-012", "title": "Outlook Configuration and Sync Issues", "url": "https://intranet.company.com/kb/012"}
    }
    
    for key, article in kb_database.items():
        if key in query.lower():
            return article
    return {"id": "KB-999", "title": "General Troubleshooting", "url": "https://intranet.company.com/kb/999"}

def execute_function_call(function_name, arguments):
    """Route function calls to their implementations"""
    if function_name == "create_ticket":
        return create_ticket_impl(**arguments)
    elif function_name == "get_kb_article":
        return get_kb_article_impl(**arguments)
    elif function_name == "escalate_incident":
        return {"status": "escalated", "message": "Senior engineer notified"}
    return {"error": "Unknown function"}


Main interaction loop

print("IT Helpdesk Agent initialized. Type 'exit' to quit.\n")

while True:
    user_input = input("Employee: ")
    if user_input.lower() == 'exit':
        break
    
    response = call_holysheep(user_input)
    
    # Check if model wants to call a function
    if 'choices' in response and response['choices'][0]['message'].get('tool_calls'):
        for tool_call in response['choices'][0]['message']['tool_calls']:
            function_name = tool_call['function']['name']
            arguments = json.loads(tool_call['function']['arguments'])
            
            print(f"\n🤖 Agent Action: Calling {function_name}")
            print(f"   Arguments: {json.dumps(arguments, indent=2)}")
            
            # Execute the function
            result = execute_function_call(function_name, arguments)
            print(f"   Result: {json.dumps(result, indent=2)}\n")
            
            # Send result back to model for final response
            messages = [
                {"role": "system", "content": "You are an IT helpdesk triage agent."},
                {"role": "user", "content": user_input},
                {"role": "assistant", "content": None, "tool_calls": [tool_call]},
                {"role": "tool", "tool_call_id": tool_call['id'], "content": json.dumps(result), "name": function_name}
            ]
            
            final_response = requests.post(
                f"{BASE_URL}/chat/completions",
                headers={"Authorization": f"Bearer {HOLYSHEEP_API_KEY}", "Content-Type": "application/json"},
                json={"model": "gpt-4.1", "messages": messages, "temperature": 0.3}
            )
            
            print(f"Agent: {final_response.json()['choices'][0]['message']['content']}\n")
    else:
        print(f"Agent: {response['choices'][0]['message']['content']}\n")

Step 2: Test the Ticketing Agent

Run the script and try these test inputs:

# Test Case 1: Simple issue requiring ticket creation

Employee: "My laptop won't connect to the office WiFi. I've tried restarting but it still shows 'Cannot connect to network'."



Expected behavior: Agent creates ticket with category=network, priority=medium



Test Case 2: Issue with known solution


Employee: "I forgot my email password and need to reset it urgently for a client meeting."



Expected behavior: Agent searches KB first, finds KB-001, provides self-service link



Test Case 3: Critical escalation


Employee: "Our entire Shanghai office is locked out of the ERP system. This is blocking 50+ people from processing orders!"



Expected behavior: Agent escalates immediately with high priority

Part 2: CRM Lead Qualification Agent

Scenario Overview

Your sales team receives 50+ inbound leads daily through your CRM. Manually qualifying each lead wastes 3-4 hours and causes high-value prospects to slip through the cracks. We will build an agent that automatically scores leads, enriches their data, routes them to the correct sales rep, and schedules follow-up tasks.

CRM Agent Implementation

"""
HolySheep AI Function Calling - CRM Lead Qualification Agent
"""

import requests
import json
from datetime import datetime, timedelta

HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY"
BASE_URL = "https://api.holysheep.ai/v1"


CRM-specific function definitions

crm_functions = [
    {
        "type": "function",
        "function": {
            "name": "get_lead_history",
            "description": "Retrieve all previous interactions with a lead from CRM",
            "parameters": {
                "type": "object",
                "properties": {
                    "lead_email": {"type": "string", "format": "email"},
                    "include_activities": {
                        "type": "boolean", 
                        "default": True
                    }
                },
                "required": ["lead_email"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "score_lead",
            "description": "Calculate lead score based on company size, budget, timeline, and engagement",
            "parameters": {
                "type": "object",
                "properties": {
                    "company_size": {"type": "string", "enum": ["startup", "smb", "midmarket", "enterprise"]},
                    "stated_budget": {"type": "string"},
                    "decision_timeline": {"type": "string"},
                    "website_visits_last_30d": {"type": "integer"},
                    "email_engagement_score": {"type": "number", "minimum": 0, "maximum": 100},
                    "form_completions": {"type": "integer"}
                },
                "required": ["company_size", "email_engagement_score"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "route_to_rep",
            "description": "Assign lead to appropriate sales representative based on territory and product fit",
            "parameters": {
                "type": "object",
                "properties": {
                    "lead_id": {"type": "string"},
                    "industry": {"type": "string"},
                    "company_size": {"type": "string"},
                    "estimated_value": {"type": "number"}
                },
                "required": ["lead_id", "industry"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "schedule_follow_up",
            "description": "Create a follow-up task in the CRM calendar",
            "parameters": {
                "type": "object",
                "properties": {
                    "lead_id": {"type": "string"},
                    "rep_name": {"type": "string"},
                    "activity_type": {"type": "string", "enum": ["call", "email", "meeting", "demo"]},
                    "scheduled_date": {"type": "string", "format": "date"},
                    "notes": {"type": "string"}
                },
                "required": ["lead_id", "rep_name", "activity_type", "scheduled_date"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "enrich_company_data",
            "description": "Look up additional company information from external sources",
            "parameters": {
                "type": "object",
                "properties": {
                    "company_name": {"type": "string"},
                    "existing_data": {"type": "object"}
                },
                "required": ["company_name"]
            }
        }
    }
]

def process_lead(lead_data):
    """
    End-to-end lead qualification pipeline using HolySheep AI
    """
    headers = {
        "Authorization": f"Bearer {HOLYSHEEP_API_KEY}",
        "Content-Type": "application/json"
    }
    
    system_prompt = """You are an expert B2B sales development representative (SDR).
Your mission is to qualify inbound leads and ensure high-value prospects get immediate attention.

Scoring Criteria:
- Enterprise + Decision Timeline Q1 = Hot Lead (score 90+)
- Mid-market + Budget confirmed = Warm Lead (score 70-89)
- Startup + No budget = Cold Lead (score 40-69)
- Any company + No engagement = Nurture (score below 40)

Always:
1. Check lead history before qualifying
2. Enrich data for enterprise prospects
3. Route HOT leads within 15 minutes
4. Schedule follow-up for all qualified leads"""

    messages = [
        {"role": "system", "content": system_prompt},
        {"role": "user", "content": f"Please qualify this lead:\n{json.dumps(lead_data, indent=2)}"}
    ]
    
    payload = {
        "model": "gpt-4.1",
        "messages": messages,
        "tools": crm_functions,
        "tool_choice": "auto",
        "temperature": 0.2
    }
    
    response = requests.post(
        f"{BASE_URL}/chat/completions",
        headers=headers,
        json=payload
    )
    
    return response.json()


Example lead data

sample_lead = {
    "id": "LEAD-2024-0156",
    "name": "Zhang Wei",
    "email": "[email protected]",
    "company": "Global Tech Solutions",
    "company_size": "500-1000 employees",
    "industry": "Manufacturing",
    "source": "Webinar Registration",
    "submitted_data": {
        "interest": "ERP Integration Package",
        "current_solution": "Manual processes with spreadsheets",
        "timeline": "Q2 2024 (within 3 months)",
        "budget_range": "¥500,000 - ¥1,000,000"
    },
    "engagement": {
        "website_visits": 12,
        "email_opens": 8,
        "webinar_attendance": "Yes - Full session",
        "downloads": ["ERP Buyer Guide", "ROI Calculator"]
    }
}

print("Processing lead with HolySheep AI CRM Agent...\n")
result = process_lead(sample_lead)

if 'choices' in result:
    message = result['choices'][0]['message']
    print(f"Initial Response: {message.get('content', 'Processing...')}")
    
    if message.get('tool_calls'):
        print("\n📞 Function Calls Initiated:")
        for tool in message['tool_calls']:
            func_name = tool['function']['name']
            args = json.loads(tool['function']['arguments'])
            print(f"  - {func_name}: {args}")

Part 3: ERP Inventory Query Agent

Scenario Overview

Warehouse managers and procurement teams need real-time inventory visibility across multiple warehouses. Searching through ERP systems manually wastes 2+ hours daily. We will build an agent that answers natural language queries like "What is our stock level for SKU-XYZ across all warehouses?" and performs inventory adjustments.

ERP Agent Implementation

"""
HolySheep AI Function Calling - ERP Inventory Query Agent
"""

import requests
import json

HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY"
BASE_URL = "https://api.holysheep.ai/v1"

erp_functions = [
    {
        "type": "function",
        "function": {
            "name": "query_inventory",
            "description": "Look up current inventory levels for products across warehouses",
            "parameters": {
                "type": "object",
                "properties": {
                    "sku": {"type": "string", "description": "Product SKU or partial match"},
                    "warehouse_code": {"type": "string", "description": "Specific warehouse ID (optional)"},
                    "include_reserved": {"type": "boolean", "default": True}
                },
                "required": ["sku"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "check_reorder_point",
            "description": "Determine if product needs reordering based on current stock and demand forecast",
            "parameters": {
                "type": "object",
                "properties": {
                    "sku": {"type": "string"},
                    "forecast_days": {"type": "integer", "default": 30}
                },
                "required": ["sku"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "adjust_inventory",
            "description": "Record inventory adjustment (damage, return, count correction)",
            "parameters": {
                "type": "object",
                "properties": {
                    "sku": {"type": "string"},
                    "warehouse_code": {"type": "string"},
                    "quantity_change": {"type": "integer", "description": "Positive for additions, negative for reductions"},
                    "reason": {"type": "string", "enum": ["damage", "return", "cycle_count", "theft", "other"]},
                    "reference_number": {"type": "string"}
                },
                "required": ["sku", "warehouse_code", "quantity_change", "reason"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "get_supplier_lead_time",
            "description": "Check expected delivery time from primary supplier",
            "parameters": {
                "type": "object",
                "properties": {
                    "sku": {"type": "string"},
                    "quantity_needed": {"type": "integer"}
                },
                "required": ["sku"]
            }
        }
    }
]

def query_erp_naturally(user_question, context=None):
    """
    Convert natural language ERP queries into structured function calls
    """
    headers = {
        "Authorization": f"Bearer {HOLYSHEEP_API_KEY}",
        "Content-Type": "application/json"
    }
    
    context_str = f"\n\nCurrent Context:\n{json.dumps(context, indent=2)}" if context else ""
    
    payload = {
        "model": "gpt-4.1",
        "messages": [
            {
                "role": "system",
                "content": """You are an ERP inventory specialist. Translate natural language queries 
into precise inventory lookups. You have access to these functions:
- query_inventory: Check stock levels
- check_reorder_point: See if reorder needed
- adjust_inventory: Record stock changes
- get_supplier_lead_time: Check supplier delivery times

Always verify SKU codes before executing adjustments.
When users ask about low stock, combine query_inventory + check_reorder_point."""
            },
            {
                "role": "user",
                "content": f"User Question: {user_question}{context_str}"
            }
        ],
        "tools": erp_functions,
        "tool_choice": "auto",
        "temperature": 0.1
    }
    
    response = requests.post(
        f"{BASE_URL}/chat/completions",
        headers=headers,
        json=payload
    )
    
    return response.json()


Interactive example

print("ERP Inventory Query Agent - Natural Language Interface\n")
print("Available commands: query stock, check reorder, adjust inventory, check lead times\n")

test_queries = [
    "What's our current stock for SKU-AUTO-001?",
    "Do we need to reorder USB-C cables? Check across all warehouses.",
    "Record damage of 5 units for SKU-AUTO-001 at WH-SHANGHAI-01, reference INV-ADJ-2024-089"
]

for query in test_queries:
    print(f"\n{'='*60}")
    print(f"Query: {query}")
    result = query_erp_naturally(query)
    
    if 'choices' in result:
        msg = result['choices'][0]['message']
        if msg.get('tool_calls'):
            print("Functions to execute:")
            for tc in msg['tool_calls']:
                args = json.loads(tc['function']['arguments'])
                print(f"  → {tc['function']['name']}: {args}")
        else:
            print(f"Response: {msg.get('content', 'No response')}")

Performance Benchmarks: HolySheep AI vs. Alternatives

Metric HolySheep AI (GPT-4.1) OpenAI Direct Self-Hosted (8x A100)
Function Call Accuracy 97.2% 96.8% 94.5%
Average Latency (ms) 47ms 134ms 380ms
P99 Latency (ms) 89ms 245ms 890ms
Cost per 1K Function Calls $0.42 $0.68 $2.10 (infrastructure)
Setup Time 5 minutes 10 minutes 2-4 weeks
Maintenance Overhead None Low High (GPU, infra, updates)

Common Errors and Fixes

Error 1: "Invalid API Key" or 401 Authentication Error

Symptom: API returns {"error": {"code": "invalid_api_key", "message": "..."}} or HTTP 401 status.

Cause: The API key is missing, malformed, or you are using an OpenAI key with the HolySheep endpoint.

# WRONG - This will fail:
BASE_URL = "https://api.holysheep.ai/v1"
api_key = "sk-openai-xxxxx"  # This is an OpenAI key!


CORRECT - Use your HolySheep API key:

BASE_URL = "https://api.holysheep.ai/v1"
api_key = "hs_live_xxxxxxxxxxxx"  # Get this from https://www.holysheep.ai/dashboard"


Verify your key format matches HolySheep's dashboard output

headers = {
    "Authorization": f"Bearer {api_key}",
    "Content-Type": "application/json"
}


Test the connection:

test_response = requests.get(
    f"{BASE_URL}/models",
    headers=headers
)
print(test_response.json())

Error 2: "tool_calls not supported for model" or 400 Bad Request

Symptom: Function calling requests fail with model compatibility error.

Cause: You are trying to use Function Calling with a model that does not support it (like some older or fine-tuned models).

# WRONG - Not all models support function calling:
payload = {
    "model": "gpt-3.5-turbo",  # Does not support function calling well
    "tools": functions,
    # ...
}


CORRECT - Use models optimized for function calling:

payload = {
    "model": "gpt-4.1",  # HolySheep's recommended model for function calling
    # or use:
    # "model": "claude-sonnet-4.5",
    "tools": functions,
    "tool_choice": "auto"
}


Check available models with function calling support:

models_response = requests.get(
    f"{BASE_URL}/models",
    headers={"Authorization": f"Bearer {HOLYSHEEP_API_KEY}"}
)
for model in models_response.json().get('data', []):
    if 'function' in str(model).lower():
        print(f"Function calling supported: {model['id']}")

Error 3: "Missing required parameter: messages" or Validation Error

Symptom: API returns 422 Unprocessable Entity with validation error.

Cause: Request payload is missing required fields or has incorrect JSON structure.

# WRONG - Missing messages array:
payload = {
    "model": "gpt-4.1",
    "content": "Hello"  # Wrong field name!
}


CORRECT - Proper message format:

payload = {
    "model": "gpt-4.1",
    "messages": [
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Hello"}
    ]
}


Also ensure JSON is properly serialized:

import json

response = requests.post(
    f"{BASE_URL}/chat/completions",
    headers={
        "Authorization": f"Bearer {HOLYSHEEP_API_KEY}",
        "Content-Type": "application/json"
    },
    data=json.dumps(payload),  # Use data= with json.dumps, not json= with dict
    timeout=30
)


Debugging tip: print the exact payload you're sending

print(json.dumps(payload, indent=2))

Error 4: Rate Limit Exceeded (429 Status)

Symptom: API returns {"error": {"code": "rate_limit_exceeded", ...}}

Cause: Too many requests per minute or exceeded monthly quota.

# Implement exponential backoff for rate limit handling:
import time

def call_with_retry(payload, max_retries=3):
    headers = {
        "Authorization": f"Bearer {HOLYSHEEP_API_KEY}",
        "Content-Type": "application/json"
    }
    
    for attempt in range(max_retries):
        response = requests.post(
            f"{BASE_URL}/chat/completions",
            headers=headers,
            json=payload,
            timeout=30
        )
        
        if response.status_code == 200:
            return response.json()
        elif response.status_code == 429:
            wait_time = (2 ** attempt) + 1  # 2, 4, 8 seconds
            print(f"Rate limited. Waiting {wait_time} seconds...")
            time.sleep(wait_time)
        else:
            print(f"Error {response.status_code}: {response.text}")
            return None
    
    return None


Usage:

result = call_with_retry({
    "model": "gpt-4.1",
    "messages": [{"role": "user", "content": "Hello"}]
})

Error 5: Function Arguments Not Matching Schema

Symptom: The AI calls a function but with incorrect argument types or missing required fields.

Cause: Function parameter definitions are ambiguous or the model misinterprets the expected format.

# WRONG - Ambiguous parameter definitions:
{
    "name": "create_ticket",
    "parameters": {
        "properties": {
            "priority": {"type": "string"}  # No enum constraints!
        }
    }
}


CORRECT - Explicit constraints guide the model:

{
    "name": "create_ticket",
    "description": "Create a support ticket. Priority affects response time SLA.",
    "parameters": {
        "type": "object",
        "properties": {
            "priority": {
                "type": "string",
                "enum": ["critical", "high", "medium", "low"],
                "description": "Critical = 1hr response, High = 4hr, Medium = 24hr, Low = 72hr"
            },
            "

Related Resources
Related Articles