Jio Platforms & Airtel: AI / GenAI Engineer

• Convolution: learned filters slide over the image computing local weighted sums, detecting edges, textures and parts. Weight sharing cuts parameters, and the operation is translation-equivariant.
• Pooling: downsampling (max/avg) adds some translation invariance and grows the receptive field.
• Depth: early layers learn edges, middle layers motifs, deep layers object parts. Residual connections (ResNet) allow very deep networks.
• Be precise about your project: input size, architecture, augmentation, metrics, what failed. The interviewer will probe exactly those claims.

from typing import TypedDict, List
from langgraph.graph import StateGraph, END

class S(TypedDict): question: str; docs: List[str]; answer: str; route: str

def router(s):   s["route"] = "retrieve" if needs_kb(s["question"]) else "direct"; return s
def retrieve(s): s["docs"] = retriever.invoke(s["question"]); return s
def generate(s): s["answer"] = llm_answer(s["question"], s.get("docs", [])); return s

g = StateGraph(S)
g.add_node("router", router); g.add_node("retrieve", retrieve); g.add_node("generate", generate)
g.set_entry_point("router")
g.add_conditional_edges("router", lambda s: s["route"], {"retrieve": "retrieve", "direct": "generate"})
g.add_edge("retrieve", "generate"); g.add_edge("generate", END)
app = g.compile()

• Explain: typed state, conditional routing, adding a grader node (is the context relevant? if not, rewrite the query and retry), checkpointing for memory, and tracing.

• System policy: scope (only telecom account topics), tone, languages, escalation triggers.
• Guardrails: input filters (abuse, jailbreaks), PII masking, allow-listed tools (bill lookup, plan change with OTP confirmation), output checks (no false promises about refunds).
• Tool permissions: read-only by default; write actions need user confirmation and an audit log.
• Evaluation: a red-team test set, resolution rate, CSAT, escalation correctness.

// Node (Express) — Server-Sent Events
app.post("/chat", async (req, res) => {
  res.setHeader("Content-Type", "text/event-stream");
  res.setHeader("Cache-Control", "no-cache");
  for await (const chunk of llm.stream(req.body.messages)) res.write(`data: ${JSON.stringify(chunk)}\n\n`);
  res.end();
});

// React — read the stream and append tokens to state
const [text, setText] = useState("");
async function send(messages) {
  const r = await fetch("/chat", { method: "POST", headers: {"Content-Type": "application/json"}, body: JSON.stringify({ messages }) });
  const reader = r.body.getReader(); const dec = new TextDecoder();
  for (;;) { const { value, done } = await reader.read(); if (done) break;
    dec.decode(value).split("\n\n").filter(Boolean).forEach(l => setText(t => t + JSON.parse(l.slice(6)).delta)); }
}

• Mention abort controllers (stop generation), back-pressure, and error states in the UI.

• Channels: app chat, WhatsApp, IVR voice (ASR/TTS in 10+ Indian languages).
• Router: an intent classifier sends frequent simple intents (balance, recharge) to deterministic flows (cheap, fast) and complex ones to an LLM agent with tools and RAG over policies.
• Scale: autoscaled stateless services, caching of FAQ answers, regional deployments, rate limits; cost control with small models for routing.
• Quality and safety: an evaluation set per language, human handoff, monitoring of containment rate, CSAT and hallucination flags.

def balanced(s):
    pairs, st = {")": "(", "]": "[", "}": "{"}, []
    for ch in s:
        if ch in "([{": st.append(ch)
        elif ch in pairs:
            if not st or st.pop() != pairs[ch]: return False
    return not st