తెలుగులో మొదటిసారిగా How to Build Low-Cost Multi-LLM Chatbots for Customer Service In Telugu

ఈ మధ్యకాలంలో ఎక్కడ చూసినా AI హడావిడి మామూలుగా లేదు. ఒక చిన్న Return Policy లేదా “మీ ఆఫీస్ టైమింగ్స్ ఏంటి బాసూ?” అని అడిగే బేసిక్ కస్టమర్ క్వెరీ కి కూడా మనోళ్లు పెద్ద పీకుడుగాడిలా GPT-4o లేదా Claude 3.5 Sonnet లాంటి హెవీ కాస్ట్ మోడల్స్ ని వాడేసి బిల్స్ తడిసి మోపెడయ్యేలా చేసుకుంటున్నారు. నెల తిరిగేసరికి OpenAI నుండి వేల డాలర్ల బిల్లు చూసి గుండె ఆగిపోవడం ఖాయం. ఒక కంపెనీకి కస్టమర్ సర్వీస్ Chatbot పెట్టట్టినప్పుడు దానికి వచ్చే 80 శాతం ప్రశ్నలు చాలా అల్లాటప్పాగా ఉంటాయి. వాటికి కూడా కోట్లు పోసి కొన్న బ్రెయిన్ లాంటి GPT-4o ని వాడితే సంక నాకిపోవడం కాక మరేమవుతుంది?

ఇక్కడే మనకు ఉపయోగపడే అసలైన టెక్నాలజీ: Dynamic Routing. అంటే కస్టమర్ అడిగే ప్రశ్నను బట్టి, అది సింపుల్ ప్రశ్నా, మీడియం క్వెరీనా లేదా చాలా కాంప్లెక్స్ సమస్యనా అనేది ఒక Intent Classifier ద్వారా ముందే కనిపెట్టి, దానికి తగ్గట్టుగా Gemini 2.0 Flash, Claude 3.5 Haiku లేదా GPT-4o కి కనెక్ట్ చేయడం. దీనివల్ల కస్టమర్ కి కావాల్సిన ఆన్సర్ సెకన్లలో వస్తుంది, నీ జేబుకి పడే బొక్క కూడా 80 శాతం వరకు తగ్గుతుంది.

ఈ బ్లాగ్ లో అసలు సోది లేకుండా, ఎక్కడ క్లిక్ చేయాలి, ఏ Webhook క్రియేట్ చేయాలి, n8n లో ఎలా Nodes సెట్ చేయాలో పాయింట్ టు పాయింట్ వివరిస్తాను. జాగ్రత్తగా లాప్‌టాప్ ఓపెన్ చేసి లైన్ బై లైన్ ప్రాక్టీస్ చేయి!

Chatbots for Customer Service In Telugu: Step By Step Process

1. The Multi-LLM Routing Reality Check: అసలు ఎందుకు ఈ లత్కోర్ బిల్లింగ్ తలనోప్పి?

చాలామంది సోషల్ మీడియాలో తిరిగే తుప్పాసి ఎదవలు ఒకటే చెప్తారు: “GPT-4o వాడేయండి బాసూ, మీ బిజినెస్ అంతా ఆటోమేట్ అయిపోద్ది.” అది వినడానికి బానే ఉంటుంది కానీ, ప్రాక్టికల్ గా ఒక ఈ-కామర్స్ సైట్ కో లేదా ట్రావెల్ ఏజెన్సీ కో రోజుకి 10,000 చాట్స్ వస్తే, వాటన్నింటికీ GPT-4o API వాడితే నెలకి కనీసం 5,000 డాలర్ల బిల్లు వస్తుంది. ఆ బిల్లు కట్టడానికి చివరికి నువ్వు AI Startups కోసం లోన్స్ ఎలా పొందాలి: How to Get AI Startup Loan In Telugu ఎదవ సోది లేకుండా 100% Simple Telugu Guide అనే నా పాత బ్లాగ్ చదువుకుంటూ తిరగాల్సి వస్తుంది.

అసలు ప్రాబ్లమ్ ఎక్కడ వస్తుందంటే:

• Input Tokens & Context Window: ప్రతిసారి కస్టమర్ చాట్ మెసేజ్ పంపినప్పుడు, పాత చాట్ హిస్టరీ మొత్తాన్ని Context కింద మోడల్ కి పంపాలి. దీనివల్ల Input Tokens విపరీతంగా పెరిగిపోయి బిల్లు పిచ్చెక్కిపోద్ది.
• Simple Intent vs Complex Intent: కస్టమర్ “హలో” అని మెసేజ్ పెడితే దానికి రిప్లై ఇవ్వడానికి GPT-4o అవసరమా? Gemini 2.0 Flash లేదా Claude 3.5 Haiku వాడితే పైసా ఖర్చు లేకుండా పని అయిపోద్ది కదా!
• Latency (రెస్పాన్స్ స్పీడ్): పెద్ద మోడల్స్ కి రెస్పాన్స్ ఇవ్వడానికి టైమ్ పడుతుంది. కస్టమర్ సర్వీస్ లో కస్టమర్ కి వెయిటింగ్ టైమ్ పెరిగిందంటే వాడు నీ సైట్ వదిలేసి వేరే వాడి దగ్గరికి వెళ్ళిపోతాడు.

అందుకే మనకు ఒక Dynamic Router కావాలి. ఇది ఒక ఓపెన్-రోడ్ ట్రాఫిక్ పోలీస్ లాగా పనిచేస్తుంది. ప్రశ్న చాలా నార్మల్ గా ఉంటే తక్కువ కాస్ట్ ఉన్న Gemini Flash కి పంపుతుంది. అదే ఒకవేళ కస్టమర్ “నా ఆర్డర్ ఐడీ 123456 ట్రాక్ చేయి, నా పేమెంట్ కట్ అయింది కానీ ఆర్డర్ ప్లేస్ కాలేదు” అని అడిగితే, దాన్ని కాంప్లెక్స్ క్వెరీ కింద మార్క్ చేసి Claude 3.5 Sonnet కి పంపి డేటాబేస్ ని చెక్ చేయిస్తుంది.

2. Dynamic Routing Core Architecture: నిజంగా బ్యాకెండ్ లో ఏం జరుగుతుంది?

మనం బిల్డ్ చేయబోయే Dynamic Routing Multi-LLM Chatbot లో ప్రధానంగా ఈ కింది భాగాలు ఉంటాయి:

[Customer Query] ---> (Intent & Complexity Classifier LLM)
                                 |
        ---------------------------------------------------
        |                        |                        |
 [Low-Complexity]       [Medium-Complexity]      [High-Complexity]
        |                        |                        |
 (Gemini 2.0 Flash)     (GPT-4o-Mini/Haiku)     (Claude 3.5 Sonnet)
        |                        |                        |
        ---------------------------------------------------
                                 |
                        [Response to Customer]

ఇక్కడ ఫస్ట్ స్టెప్ లో వచ్చే కస్టమర్ క్వెరీ ని Intent Classifier Node కి పంపుతాం. ఈ Classifier లో ఒక చిన్న ప్రాంప్ట్ ఉంటుంది. అది కేవలం JSON అవుట్‌పుట్ మాత్రమే ఇస్తుంది. ఉదాహరణకి కస్టమర్ అడిగిన మెసేజ్ ని బట్టి:

{
  "complexity": "low",
  "intent": "greeting"
}

ఈ JSON డేటాను బేస్ చేసుకుని మన సిస్టమ్ లో ఉండే Switch Node కరెక్ట్ బ్రాంచ్ కి కనెక్షన్ ని రీడైరెక్ట్ చేస్తుంది.

3. Step-by-Step Click-by-Click Guide to Build the Bot in n8n

ఒకవేళ నీకు కోడింగ్ రాకపోతే కంగారు పడకు. కోడింగ్ లేకుండా కూడా అద్భుతమైన AI సిస్టమ్స్ క్రియేట్ చేయొచ్చు. ఆల్రెడీ నా పాత ఆర్టికల్ No-Code AI SaaS Business in Telugu (Coding లేకుండా AI SAAS Building) లో చెప్పినట్టు, నో-కోడ్ టూల్స్ తో సాస్ బిజినెస్ లు కూడా రన్ చేయొచ్చు. ఇప్పుడు మనం n8n టూల్ ఉపయోగించి ఈ Dynamic Routing బాట్ ని క్లిక్-బై-క్లిక్ ఎలా సెట్ చేయాలో చూద్దాం.

Step 1: n8n లో కొత్త Workflow క్రియేట్ చేయుట

మొదటగా నీ n8n డాష్‌బోర్డ్ లోకి login అవ్వు. కుడి పక్కన పైన నీకు “Create Workflow” అనే బటన్ కనిపిస్తుంది. దాని మీద click చేయి. నీకు ఒక ఖాళీ క్యాన్వాస్ ఓపెన్ అవుతుంది.

Step 2: Webhook Trigger ని సెట్ చేయడం

మనం కస్టమర్ చాట్ విడ్జెట్ నుండి లేదా WhatsApp నుండి మెసేజ్ ని స్వీకరించడానికి ఒక Webhook ని క్రియేట్ చేయాలి.

• క్యాన్వాస్ మధ్యలో ఉన్న “+” icon మీద click చేయి.
• కుడి పక్కన ఓపెన్ అయిన సెర్చ్ బాక్స్ లో “Webhook” అని టైప్ చేయి.
• లిస్ట్ లో కనిపించే “Webhook” node ని సెలెక్ట్ చేయి. అది క్యాన్వాస్ మీదకి వస్తుంది.
• ఆ Node మీద double click చేయి. ఎడమ పక్కన దాని సెట్టింగ్స్ ఓపెన్ అవుతాయి.
• HTTP Method: డ్రాప్‌డౌన్ లో POST అని సెలెక్ట్ చేయి.
• Path: ఇక్కడ customer-query అని టైప్ చేయి.
• Response Mode: డ్రాప్‌డౌన్ లో When Last Node Finishes అని సెలెక్ట్ చేయి (ఎందుకంటే చివరన వచ్చే LLM రెస్పాన్స్ ని మనం కస్టమర్ కి తిరిగి పంపాలి).
• పైన ఉన్న “Production URL” ని కాపీ చేసి పెట్టుకో. నీ చాట్ విడ్జెట్ ఈ URL కే డేటా పంపాలి.

Step 3: Intent Classifier Node ని యాడ్ చేయడం

ఇప్పుడు కస్టమర్ పంపిన మెసేజ్ ని క్లాసిఫై చేయడానికి ఒక చిన్న, ఫాస్ట్ మోడల్ ని వాడదాం. దీని కోసం Gemini 2.0 Flash బెస్ట్. ఎందుకంటే దీని స్పీడ్ దూల తీరిపోద్ది, కాస్ట్ కూడా దాదాపు ఫ్రీ.

• Webhook node కి కుడి పక్కన ఉన్న “+” icon మీద click చేయి.
• సెర్చ్ బాక్స్ లో “Google Gemini” లేదా “OpenAI” అని టైప్ చేసి, “Advanced AI” కేటగిరీ లోని “AI Agent” లేదా “Basic LLM Chain” node ని సెలెక్ట్ చేయి.
• ఆ Node కి కింద రెండు కనెక్టర్లు ఉంటాయి. ఒకదానిలో “Model” అని రాసి ఉంటుంది. ఆ కనెక్టర్ నుండి డ్రాగ్ చేసి “+” క్లిక్ చేసి “Google Gemini Chat Model” ని సెలెక్ట్ చేయి.
• ఆ మోడల్ లో నీ API కీ ఎంటర్ చేసి, మోడల్ నేమ్ డ్రాప్‌డౌన్ లో gemini-1.5-flash లేదా gemini-2.0-flash సెలెక్ట్ చేయి.
• System Prompt: ఈ కింద ఉన్న ప్రాంప్ట్ ని కాపీ చేసి సిస్టమ్ ప్రాంప్ట్ బాక్స్ లో పేస్ట్ చేయి:

  You are an extremely fast and accurate customer query complexity classifier.
  Your job is to analyze the user message and classify it into one of these three categories:
  - "low": Simple greetings, office hours, or generic questions.
  - "medium": Questions about order status tracking, specific product information, or requests that require external data lookup.
  - "high": Complex issues, billing complaints, custom integration questions, or angry customer rants.

  You must output ONLY a valid JSON object with the following format. Do not write any explanations or markdown:
  {
    "complexity": "low" | "medium" | "high",
    "intent": "string descriptive of intent"
  }

• Input Prompt: Webhook నుండి వచ్చిన బాడీ డేటా లోని కస్టమర్ మెసేజ్ ని ఇక్కడ డ్రాగ్ అండ్ డ్రాప్ చేయి (n8n లో {{ $json.body.message }} అని ఉంటుంది).

Step 4: JSON Parsing మరియు Switch Node సెట్ చేయడం

Gemini ఇచ్చిన రెస్పాన్స్ JSON టెక్స్ట్ లా ఉంటుంది. దాన్ని మనం n8n కి అర్థమయ్యేలా మార్చాలి.

• AI Agent node పక్కన ఉన్న “+” మీద click చేసి “Code” node ని యాడ్ చేయి.
• అందులో లాంగ్వేజ్ “JavaScript” సెలెక్ట్ చేసి, ఈ కింద ఉన్న కోడ్ ని రాయి:

  const cleanJson = inputData[0].json.output.replace(/```json|```/g, "").trim();
  const parsedData = JSON.parse(cleanJson);
  return [{ json: parsedData }];

• ఇప్పుడు ఈ Code node పక్కన ఉన్న “+” క్లిక్ చేసి “Switch” node ని సెర్చ్ చేసి యాడ్ చేయి.
• Data Type: డ్రాప్‌డౌన్ లో String అని సెలెక్ట్ చేయి.
• Value 1: ఇక్కడ {{ $json.complexity }} అని రాయాలి.
• Rules Section: ఇక్కడ మూడు రూల్స్ యాడ్ చేయి:

1. Operation: Equal, Value: low —> ఇది బ్రాంచ్ 1 కి వెళ్తుంది.
2. Operation: Equal, Value: medium —> ఇది బ్రాంచ్ 2 కి వెళ్తుంది.
3. Operation: Equal, Value: high —> ఇది బ్రాంచ్ 3 కి వెళ్తుంది.

• 

  Pinky SaaS Info

  FREE Zoho CRM: A Simple Tool for Real B2B Founders

  FREE Zoho CRM: A Simple Tool for Real B2B Founders If you’re a B2B founder …

  Read more

• 

  Pinky SaaS Info

  Insider Tips for Siift.ai Market Validation for Founders and AI-Powered Lean Startup Validation

  Disclaimer: We have no affiliation with Siift.ai. We do not receive a single rupee or …

  Read more

• 

  Pinky SaaS Info

  The Ultimate Guide to Leapter AI Logic Enforcement for Startups and Verifying AI Agent Behavior with Logic Layers

  The Ultimate Guide to Leapter AI Logic Enforcement for Startups and Verifying AI Agent Behavior …

  Read more

• 

  Pinky SaaS Info

  Parloa Deep Dive: The definitive enterprise voice AI for solo founders

  Parloa Deep Dive: The definitive enterprise voice AI for solo founders Providing direct phone support …

  Read more

Step 5: మూడు బ్రాంచ్‌లలో LLM మోడల్స్ ని సెట్ చేయడం

ఇప్పుడు Switch Node కి కుడి పక్కన మూడు అవుట్‌పుట్ పాయింట్లు కనిపిస్తాయి.

Branch 1 (Low Complexity – Gemini 2.0 Flash)

• మొదటి పాయింట్ నుండి డ్రాగ్ చేసి “+” క్లిక్ చేసి “HTTP Request” లేదా “Basic LLM Chain” node ని యాడ్ చేయి.
• అందులో “Google Gemini Chat Model” ని కనెక్ట్ చేసి మోడల్ ని gemini-2.0-flash గా సెట్ చేయి.
• System Prompt: “You are a friendly customer service agent. Answer the customer query directly and concisely.”
• Query: Webhook నుండి వచ్చిన ఒరిజినల్ కస్టమర్ మెసేజ్ ని ఇక్కడ లింక్ చేయి.

Branch 2 (Medium Complexity – Claude 3.5 Haiku లేదా GPT-4o-Mini)

• రెండో పాయింట్ నుండి డ్రాగ్ చేసి ఇంకొక “Basic LLM Chain” node ని యాడ్ చేయి.
• ఇక్కడ మోడల్ గా “OpenAI Chat Model” ని సెలెక్ట్ చేసి gpt-4o-mini ని కనెక్ట్ చేయి (లేదా Anthropic Claude 3.5 Haiku వాడొచ్చు).
• ఇక్కడ మనం కస్టమర్ ఆర్డర్ డేటా ని ట్రాక్ చేయడానికి అవసరమైతే ఒక Database Query లేదా API Node ని కూడా కనెక్ట్ చేయొచ్చు.

Branch 3 (High Complexity – Claude 3.5 Sonnet)

• మూడో పాయింట్ నుండి డ్రాగ్ చేసి “Basic LLM Chain” node ని యాడ్ చేయి.
• మోడల్ గా “Anthropic Chat Model” ని సెలెక్ట్ చేసి claude-3-5-sonnet ని కనెక్ట్ చేయి.
• ఇది చాలా ఇంటెలిజెంట్ మోడల్ కాబట్టి, కాంప్లెక్స్ సమస్యలకి అద్భుతమైన సొల్యూషన్ ఇస్తుంది.

Step 6: Response ని తిరిగి పంపడం

ఈ మూడు LLM Nodes యొక్క అవుట్‌పుట్‌లను తీసుకెళ్లి చివరగా ఒక “Merge” Node కి కనెక్ట్ చేయి. ఆ Merge Node ని తీసుకొచ్చి నీ Webhook కి కనెక్ట్ చేస్తే, ఏ బ్రాంచ్ నుండి రెస్పాన్స్ వచ్చినా అది డైరెక్ట్ గా కస్టమర్ స్క్రీన్ మీదకి వెళ్ళిపోతుంది.

పైన ఉన్న “Save” బటన్ క్లిక్ చేసి, కుడి పక్కన ఉన్న “Active” టోగుల్ ని ఆన్ చేయి. అంతే, నీ ఫస్ట్ Dynamic Routing Chatbot రెడీ అయిపోయింది బాసూ!

4. The Token Math: ఎక్కడ ఎంత బొక్క పడుతుందో లైవ్ Calculations

సాధారణంగా ఈ సోషల్ మీడియా మోసగాళ్లు నీకు నంబర్స్ చూపించరు. ఎందుకంటే వాళ్ళకి అసలు లెక్కలు తెలియవు, అంతా గాల్లో దీపాలు పెట్టే వ్యవహారమే. మనం ఇక్కడ 2026 లో ఉన్న లేటెస్ట్ API ధరల ప్రకారం ఒక ఈ-కామర్స్ కంపెనీ రోజుకి 10,000 క్వెరీస్ హ్యాండిల్ చేస్తే ఎంత ఖర్చవుతుందో ప్రాక్టికల్ గా చూద్దాం.

సగటున ఒక చాట్ లో 1,000 Input Tokens (పాత చాట్ హిస్టరీ తో కలిపి) మరియు 200 Output Tokens ఉంటాయి అనుకుందాం.

Case 1: All queries on GPT-4o (No Routing)

• GPT-4o API Pricing (సగటున 2026 లో): $5.00 per Million Input, $15.00 per Million Output.
• 10,000 Queries per day:
• Input Cost: 10,000 * 1,000 * ($5 / 1,000,000) = $50.00
• Output Cost: 10,000 * 200 * ($15 / 1,000,000) = $30.00
• Total Cost per Day: $80.00
• Total Cost per Month: $2,400.00 (దాదాపు 2 లక్షల రూపాయలు బొక్క!)

Case 2: Using Dynamic Routing (Gemini Flash, Haiku & Sonnet Mix)

సగటు కస్టమర్ చాట్స్ లో 70% సింపుల్ క్వెరీస్ (low), 20% మీడియం (medium), 10% మాత్రమే చాలా కాంప్లెక్స్ (high) ఉంటాయి.

1. Low Queries (70% – 7,000 queries) routed to Gemini 2.0 Flash:

• Gemini Flash API Pricing: $0.075 per Million Input, $0.30 per Million Output (అత్యంత చౌక!).
• Input: 7,000 * 1,000 * ($0.075 / 1,000,000) = $0.525
• Output: 7,000 * 200 * ($0.30 / 1,000,000) = $0.42
• Cost: $0.945

1. Medium Queries (20% – 2,000 queries) routed to GPT-4o-Mini:

• GPT-4o-Mini API Pricing: $0.150 per Million Input, $0.60 per Million Output.
• Input: 2,000 * 1,000 * ($0.150 / 1,000,000) = $0.30
• Output: 2,000 * 200 * ($0.60 / 1,000,000) = $0.24
• Cost: $0.54

1. High Queries (10% – 1,000 queries) routed to Claude 3.5 Sonnet:

• Claude Sonnet API Pricing: $3.00 per Million Input, $15.00 per Million Output.
• Input: 1,000 * 1,000 * ($3.00 / 1,000,000) = $3.00
• Output: 1,000 * 200 * ($15.00 / 1,000,000) = $3.00
• Cost: $6.00

1. Intent Classifier Cost (10,000 queries using Gemini Flash):

• ఇక్కడ ప్రతి క్వెరీ కి కేవలం కస్టమర్ ఇన్పుట్ టోకెన్స్ మాత్రమే ఉంటాయి (సగటున 100 tokens input, 50 tokens output for classification).
• Cost: 10,000 * 100 * ($0.075 / 1,000,000) + 10,000 * 50 * ($0.30 / 1,000,000) = $0.075 + $0.15 = $0.225

అసలైన బేరం చూద్దాం:

• Total Cost with Routing per Day: $0.945 (Low) + $0.54 (Medium) + $6.00 (High) + $0.225 (Classifier) = $7.71
• Total Cost with Routing per Month: $7.71 * 30 = $231.30 (దాదాపు 19,000 రూపాయలు మాత్రమే!)

కళ్ళు తిరిగాయా బాసూ? ఎక్కడ నెలకి 2 లక్షల రూపాయల బొక్క, ఎక్కడ కేవలం 19 వేల రూపాయలతో అదే క్వాలిటీ సర్వీస్! ఈ సీక్రెట్ ఏ కస్టమర్ కి తెలియదు, ఏ బిజినెస్ ఓనర్ కి అర్థం కాదు. అందుకే నువ్వు ఒక బిజినెస్ ఓనర్ దగ్గరికి వెళ్లి ఈ లెక్కలు చూపిస్తే, నిన్ను దేవుడిలా చూస్తారు.

Gemini యొక్క అద్భుతమైన అప్‌డేట్స్ గురించి తెలుసుకోవడానికి నా పాత ఆర్టికల్ AI ద్వారా కంటెంట్ బిజినెస్: Google I/O 2026 దూల తీరిపోయే Google Gemini Ecosystem Updates in Telugu ని ఒక్కసారి చదువు. గూగుల్ ఎంత పవర్ఫుల్ మోడల్స్ ని ఎంత తక్కువ రేట్ కి ఇస్తుందో నీకు క్లారిటీ వస్తుంది.

5. Python Code for Custom LLM Routing (డెవలపర్స్ కోసం రా కోడ్)

ఒకవేళ నువ్వు n8n లాంటి నో-కోడ్ టూల్స్ వాడకుండా, పక్కా కోడింగ్ ద్వారా నీ సొంత Server లేదా Cloud లో ఈ సిస్టమ్ ని రన్ చేయాలి అనుకుంటే, ఈ కింద ఉన్న Production-Ready Python కోడ్ ని వాడుకోవచ్చు.

మేము ఇందులో litellm అనే లైబ్రరీ ని వాడుతున్నాం. ఇది చాలా తోపు లైబ్రరీ, ఎందుకంటే దీని ద్వారా ఒకే కోడ్ ఫార్మాట్ లో OpenAI, Anthropic, Google Gemini మోడల్స్ ని ఈజీగా మేనేజ్ చేయొచ్చు.

మొదటగా నీ టెర్మినల్ లో ఈ లైబ్రరీస్ ని ఇన్‌స్టాల్ చేసుకో:

pip install litellm pydantic fastapi uvicorn

ఇప్పుడు ఈ కింది కోడ్ ని main.py అని సేవ్ చేసుకో:

import os
import json
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from litellm import completion

app = FastAPI(title="Dynamic Multi-LLM Router for Customer Service")

# నీ API కీస్ ఇక్కడ సెట్ చేసుకో (లేదా .env ఫైల్ వాడుకో)
os.environ["OPENAI_API_KEY"] = "your-openai-api-key"
os.environ["ANTHROPIC_API_KEY"] = "your-anthropic-api-key"
os.environ["GEMINI_API_KEY"] = "your-gemini-api-key"

class CustomerQuery(BaseModel):
    session_id: str
    message: str

class RoutingDecision(BaseModel):
    complexity: str
    intent: str

def classify_query(query: str) -> RoutingDecision:
    """
    కస్టమర్ అడిగిన క్వెరీ ని క్లాసిఫై చేసే ఫంక్షన్.
    దీనికి మనం Gemini 2.0 Flash ని వాడుతున్నాం ఎందుకంటే ఇది చాలా ఫాస్ట్ మరియు చౌక.
    """
    system_prompt = """
    You are an intent classifier. Classify the query into:
    - "low": Greeting, business hours, simple FAQ.
    - "medium": Order tracking, policy lookup, specific product spec.
    - "high": Integration help, payment failure, highly technical debugging.

    Output JSON ONLY in this format:
    {"complexity": "low"|"medium"|"high", "intent": "description"}
    """

    try:
        response = completion(
            model="gemini/gemini-2.0-flash",
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": query}
            ],
            response_format={"type": "json_object"}
        )

        # JSON క్లీనింగ్ మరియు పార్సింగ్
        result_text = response.choices[0].message.content
        data = json.loads(result_text)
        return RoutingDecision(**data)

    except Exception as e:
        # ఏమైనా ఎర్రర్ వస్తే డీఫాల్ట్ గా "medium" కి ఫాల్‌బ్యాక్ అవుతాం
        print(f"Classification failed: {e}")
        return RoutingDecision(complexity="medium", intent="fallback")

def generate_response(query: str, complexity: str) -> str:
    """
    క్లాసిఫికేషన్ ని బట్టి కరెక్ట్ మోడల్ ని పిలిచే ఫంక్షన్.
    """
    try:
        if complexity == "low":
            # లో-కాంప్లెక్సిటీ కి గూగుల్ జెమిని ఫ్లాష్
            print("Routing to Gemini 2.0 Flash...")
            response = completion(
                model="gemini/gemini-2.0-flash",
                messages=[
                    {"role": "system", "content": "You are a friendly customer agent. Keep it brief."},
                    {"role": "user", "content": query}
                ]
            )

        elif complexity == "medium":
            # మీడియం-కాంప్లెక్సిటీ కి GPT-4o-Mini
            print("Routing to GPT-4o-Mini...")
            response = completion(
                model="openai/gpt-4o-mini",
                messages=[
                    {"role": "system", "content": "You are a customer assistant. Help with order/product details."},
                    {"role": "user", "content": query}
                ]
            )

        else:
            # హై-కాంప్లెక్సిటీ కి క్లాడ్ 3.5 సోనెట్
            print("Routing to Claude 3.5 Sonnet...")
            response = completion(
                model="anthropic/claude-3-5-sonnet",
                messages=[
                    {"role": "system", "content": "You are an elite support engineer. Resolve complex technical queries."},
                    {"role": "user", "content": query}
                ]
            )

        return response.choices[0].message.content

    except Exception as e:
        # ఏదైనా API డౌన్ అయితే ఫాల్‌బ్యాక్ మోడల్ కి పంపుతాం
        print(f"Primary model failed: {e}. Falling back to GPT-4o-Mini...")
        response = completion(
            model="openai/gpt-4o-mini",
            messages=[
                {"role": "system", "content": "You are a customer assistant."},
                {"role": "user", "content": query}
            ]
        )
        return response.choices[0].message.content

@app.post("/chat")
async def chat_endpoint(payload: CustomerQuery):
    if not payload.message.strip():
        raise HTTPException(status_code=400, detail="Message cannot be empty")

    # Step 1: క్లాసిఫై చేయి
    decision = classify_query(payload.message)

    # Step 2: సరైన మోడల్ నుండి రెస్పాన్స్ తెప్పించు
    bot_response = generate_response(payload.message, decision.complexity)

    return {
        "status": "success",
        "routing": {
            "complexity": decision.complexity,
            "intent": decision.intent
        },
        "response": bot_response
    }

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

ఈ కోడ్ ని రన్ చేయడానికి నీ కమాండ్ ప్రాంప్ట్ లో python main.py అని టైప్ చేయి. సర్వర్ http://localhost:8000 లో రన్ అవుతుంది. నువ్వు పోస్ట్‌మ్యాన్ (Postman) ఓపెన్ చేసి /chat ఎండ్ పాయింట్ కి POST రిక్వెస్ట్ పంపి టెస్ట్ చేసుకోవచ్చు. ఒకవేళ క్లాడ్ API డౌన్ అయినా, ఈ కోడ్ లో రాసిన ఫాల్‌బ్యాక్ మెకానిజం వల్ల ఆటోమేటిక్ గా gpt-4o-mini కి కనెక్ట్ అయిపోతుంది. దీనివల్ల కస్టమర్ సర్వీస్ కి ఎటువంటి బ్రేక్ పడదు.

6. How to Package and Sell This as a B2B SaaS or Agency Service

నువ్వు ఈ టెక్నాలజీ బిల్డ్ చేయడం నేర్చుకున్నావ్, బానే ఉంది. మరి దీని ద్వారా డబ్బులు ఎలా సంపాదించాలి? చాలామందికి టెక్నాలజీ వచ్చినా దాన్ని ఎలా అమ్మాలో తెలియక సంక నాకిపోతారు.

ఈ అబద్ధాల సోషల్ మీడియా గురువులు చెప్పే “Gemini తో కాపీ పేస్ట్ చేసి రోజుకి 10,000 సంపాదించండి” అనే తొక్కలో సోది నమ్మకు. నిజాలు తెలుసుకోవడానికి Gemini AI ఉపయోగించి డబ్బు సంపాదించడం ఎలా? సోషల్ మీడియా అబద్ధాలు vs నిజాలు | How to Make Money Using Google Gemini in Telugu అనే నా పాత కళ్ళు తెరిపించే బ్లాగ్ చదువు.

నిజంగా మార్కెట్ లో డబ్బులు సంపాదించాలంటే ఈ కింది రెండు బెస్ట్ బిజినెస్ మోడల్స్ ఉన్నాయి:

Model A: AI Automation Agency (AAA) స్టార్ట్ చేయడం

నువ్వు లోకల్ గా ఉండే పెద్ద పెద్ద రియల్ ఎస్టేట్ కంపెనీలు, హాస్పిటల్స్, ఈ-కామర్స్ బ్రాండ్స్ దగ్గరికి వెళ్ళాలి. వాళ్ళ ఆల్రెడీ వాడుతున్న పాత కస్టమర్ సర్వీస్ బిల్స్ చూపించమనాలి. వాళ్ళకి ఈ Dynamic Routing కాన్సెప్ట్ ఎక్స్ప్లెయిన్ చేసి, వాళ్ళ బిల్లింగ్ ని సగానికి సగం తగ్గిస్తామని ఒప్పించాలి.

మరిన్ని ప్రాక్టికల్ టిప్స్ కోసం AI Automation Agency in Telugu: AI Automation Agency ఎలా ప్రారంభించాలి అనేదానిపై కంప్లీట్ ప్రాక్టికల్ గైడ్ ని ఫాలో అవ్వు. ఒక ఏజెన్సీ ని ఎలా రన్ చేయాలో నీకు ఒక SOP (Standard Operating Procedure) దొరుకుతుంది.

Model B: No-Code Multi-LLM Router SaaS బిల్డ్ చేయడం

కస్టమర్లు వాళ్ల API కీస్ ని ఎంటర్ చేసుకుని, వాళ్ల ఓన్ Dynamic Routing రూల్స్ ని సెట్ చేసుకునేలా ఒక చిన్న No-Code UI క్రియేట్ చేయి. దానికి నెలవారీ సబ్‌స్క్రిప్షన్ మోడల్ పెట్టు.

ఈ బిజినెస్ ని లీగల్ గా రిజిస్టర్ చేసి ఐటి పార్క్ లో సీటు కొట్టడానికి, ఆల్రెడీ నేను రాసిన Hyderabad లో AI Startup registration Process In Telugu గైడ్ ని కరెక్ట్ గా ఫాలో అవ్వు. అందులో చెప్పిన ప్రతి డాక్యుమెంట్ ని జాగ్రత్తగా సబ్మిట్ చేస్తే ఈజీగా రిజిస్ట్రేషన్ అయిపోతుంది.

7. T-Hub incubation కి ఈ ఐడియాని ఎలా పిచ్ చేయాలి?

ఒకవేళ నువ్వు ఈ Dynamic Routing కాన్సెప్ట్ తో ఒక నో-కోడ్ టూల్ బిల్డ్ చేసావ్ అనుకుందాం. దీన్ని ఒక ప్రాపర్ బిజినెస్ గా మార్చి, హైదరాబాద్ ఐటి హబ్ అయిన T-Hub 2.0 లో లోకల్ సీట్ దక్కించుకోవాలంటే నువ్వు ఒక పద్ధతి ఫాలో అవ్వాలి.

• అప్లికేషన్ దాఖలు చేయడం: మొదటగా నువ్వు T-Hub portal registration process స్టెప్ బై స్టెప్ కంప్లీట్ చేసి అఫీషియల్ పోర్టల్ లో నీ కంపెనీ ప్రొఫైల్ ని రిజిస్టర్ చేసుకోవాలి.
• కోహోర్ట్ లో భాగం అవ్వడం: సెలక్షన్ కమిటీ కి నీ ఐడియా నచ్చితే నిన్ను T-Hub incubator cohorts లో జాయిన్ అయ్యే విధానం కింద ల్యాబ్32 (Lab32) ప్రోగ్రాం కి షార్ట్‌లిస్ట్ చేస్తారు.
• పిచ్ రౌండ్స్ లో దుమ్ము లేపడం: చివరగా ప్యానెల్ మెంబర్స్ ముందు నీ డెమో ని చూపించి, T-Hub pitch rounds ని క్లియర్ చేయడం ఎలా అనే స్ట్రాటజీ ని ఫాలో అవ్వు. అక్కడ నీ AI ప్రొడక్ట్ వల్ల కస్టమర్లకి బిల్లింగ్ ఖర్చులు ఎలా తగ్గుతున్నాయో నీ ప్రాక్టికల్ టోకెన్ మ్యాత్ తో ప్రూవ్ చేస్తే, నీకు సీటు ఇవ్వకుండా వాళ్ళు అస్సలు ఉండలేరు బాసూ!

8. Testing, Benchmarking and Optimizing Latency: చుక్కలు చూపించే ఎర్రర్స్ ని ఎలా సాల్వ్ చేయాలి?

నువ్వు ఈ బాట్ ని బిల్డ్ చేసాక, లైవ్ లో ప్రొడక్షన్ కి పెట్టే ముందు కొన్ని ఇంపార్టెంట్ టెస్ట్‌లు చేయాలి. లేకపోతే కస్టమర్ మెసేజ్ పంపినప్పుడు బాట్ హ్యాంగ్ అయిపోయి దరిద్రంగా తయారవుతుంది.

• Latency Check: Intent Classifier గా మనం gemini-2.0-flash వాడుతున్నాం. దీని సగటు రెస్పాన్స్ టైమ్ 500ms లోపు ఉండాలి. ఒకవేళ లేటెన్సీ పెరుగుతుంటే, నీ ప్రాంప్ట్ లో ఉన్న అనవసరమైన టెక్స్ట్ ని తగ్గించు.
• Prompt Caching: గూగుల్ జెమిని మరియు క్లాడ్ లలో ప్రాంప్ట్ క్యాషింగ్ (Prompt Caching) సపోర్ట్ ఉంటుంది. నీ సిస్టమ్ ప్రాంప్ట్ లేదా నాలెడ్జ్ బేస్ డేటా పెద్దగా ఉంటే, క్యాషింగ్ ఎనేబుల్ చేయి. దీనివల్ల 90% ఇన్పుట్ టోకెన్ ఖర్చు తగ్గుతుంది, రెస్పాన్స్ కూడా సెకన్లలో దూసుకుపోతుంది.
• Rate Limits: ఒకేసారి ఎక్కువ మంది కస్టమర్లు చాట్ చేస్తే RateLimitError వస్తుంది. దీనికోసం నీ పైథాన్ కోడ్ లో లేదా n8n లో ఒక “Retry on Failure” ఆప్షన్ ని కచ్చితంగా సెట్ చేసుకోవాలి.

అసలు కథ ఇది బాసూ. ఏదో గాల్లో పిట్టల్ని కొట్టే ఐడియాలు కాకుండా, నిజంగా ఒక బిజినెస్ కి వేల డాలర్లు ఆదా చేసే ప్రాక్టికల్ Dynamic Routing AI Chatbot ని ఎలా బిల్డ్ చేయాలో నీకు నిక్కచ్చిగా, ఒక ఫ్రెండ్ పక్కన కూర్చుని చెప్పినట్టు వివరించాను.

నువ్వు గనుక నిజమైన సీరియస్ ఫౌండర్ వి అయితే, ఇప్పుడే n8n ఓపెన్ చేసి ప్రాక్టీస్ చెయ్. ఎక్కడైనా ఎర్రర్ వస్తే నీ కోడ్ ని, API కీస్ ని ఒకసారి రీ-చెక్ చేసుకో. అంతే కానీ ఈ సోషల్ మీడియా పిచ్చి సోది గాళ్ల వీడియోలు చూసి టైమ్ వేస్ట్ చేసుకోకు. ప్రొడక్ట్ బిల్డ్ చెయ్, మార్కెట్ లోకి వెళ్ళు, డబ్బులు సంపాదించు! ఏమైనా డౌట్స్ ఉంటే కామెంట్స్ లో అడుగు, జాగ్రత్త బాసూ!