Q: Design a real-time AI recommendation system.

A real-time recommendation system uses a two-stage approach: a fast candidate generation step (Retrieval via Vector Search) followed by a heavy ranking step (Learning to Rank model) to sort the candidates based on user context. 1. **Embeddings**: Both Users and Items (movies, products) are embedded into the same vector space. User embeddings update periodically based on their history. 2. **Candidate Generation (Retrieval)**: When a user logs in, query the Vector DB with the User's embedding to retrieve the top 500 semantically similar items (e.g., in 20ms). 3. **Ranking**: Pass those 500 items to a Ranking Model (like XGBoost or a deep neural network). The ranker scores them based on real-time context (time of day, device, trending status) and sorts them 1 to 50. 4. **Serving**: Serve the top 50 to the UI. Cache results.

Q: Design a multi-modal search system (text, image, video).

A multi-modal search system uses a unified embedding model (like CLIP) to map text, images, and video frames into the same semantic space, allowing users to query the database using any modality. 1. **Ingestion**: For images, pass through CLIP to generate a vector. For video, sample 1 frame per second, pass through CLIP, and average the vectors (or store separately with timestamps). Store all vectors in a Vector DB. 2. **Querying**: If the user types text ('dog catching frisbee'), pass the text through the text-encoder of CLIP. If they upload an image, pass it through the image-encoder. 3. **Retrieval**: Perform a standard Cosine Similarity search in the Vector DB. Because text and images share the exact same dimensional space, the text query will return the image vectors. 4. **Reranking**: Use a cross-encoder to refine the top 20 results for maximum relevance.

Q: Design an AI-powered email assistant.

An email assistant requires an event-driven architecture connected to IMAP/webhooks, an LLM for classification and summarization, a RAG pipeline for generating replies based on past correspondence, and a draft-only safety mechanism. 1. **Ingestion**: A webhook triggers when a new email arrives. 2. **Classification**: Pass the email to a small LLM to classify intent (Newsletter, Urgent, Support Request). 3. **RAG Context**: If it's a support request, query the Vector DB containing past sent emails to mimic the user's tone and find relevant facts. 4. **Generation**: Generate a response using a Prompt Template that strictly enforces the user's persona. 5. **Safety**: Do NOT auto-send. Save the generation to the user's 'Drafts' folder via the Gmail/Outlook API. Send a push notification for human review.

Q: Design a medical diagnosis assistant using AI.

A medical assistant demands maximum factual accuracy. It requires a highly specialized fine-tuned model, strict adherence to a verified medical RAG database (Pubmed/UpToDate), and absolute disclaimers regarding its non-diagnostic nature. 1. **Model**: Do not use a generic model. Use a specialized open-weight model like MedLM or heavily fine-tune a model on medical literature. 2. **Retrieval**: Use strict Hybrid Search RAG over peer-reviewed medical databases. Do not allow the model to rely on its internal pre-trained weights for medical facts. 3. **Evaluation**: Implement Self-Consistency (running the prompt 5 times and taking the majority answer) to reduce hallucination. 4. **Compliance**: System must be HIPAA compliant (no logging of PII/PHI in external APIs). Run the model locally or on a dedicated VPC. 5. **UX**: Force the user to accept a disclaimer. The prompt must include: 'You are an assistant. You cannot diagnose. End every message advising the user to see a doctor.'

Q: Design a fraud detection system powered by LLMs.

Fraud detection is a high-speed, structured data problem. Traditional ML (XGBoost) should be the core engine, while LLMs act as an investigative co-pilot to explain decisions and analyze unstructured text (like chat logs). 1. **Real-time Core**: For a credit card swipe (needs <50ms response), use a traditional ML anomaly detection model (Isolation Forest or XGBoost). An LLM is too slow and terrible at tabular math. 2. **Unstructured Data**: If fraud involves phishing emails or customer chat logs, pass that text through an LLM to extract intent and red flags (e.g., urgency, weird grammar). 3. **Explainability**: When the XGBoost model flags an account, feed its feature weights into an LLM. Prompt the LLM to generate a human-readable 'Fraud Investigation Report' for the human analyst. 4. **Agentic Actions**: An LLM agent can automatically draft emails requesting identity verification.

Question 1

Design an AI Coding Agent.

Accepted Answer

A Coding Agent requires a multi-agent architecture (Planner, Coder, Reviewer), a highly secure sandboxed execution environment (Docker), access to the codebase via a vector-backed semantic search (RAG), and a tool suite for executing tests and git commands. 1. **Architecture**: ReAct or Plan-and-Execute. A single agent gets overwhelmed. Use a Planner to break down the user request into tickets.
2. **Context**: RAG for the codebase. Use AST (Abstract Syntax Tree) parsing to chunk code logically by function/class, not just by character count. Store in a Vector DB.
3. **Tools**: File read/write, `git grep`, `npm run test`.
4. **Execution Harness**: The Coder agent writes code to a temporary workspace. A Sandbox runs the unit tests. If tests fail, the stderr is fed back to the Coder agent to self-correct.
5. **Review**: A final Reviewer agent checks for security flaws before presenting the diff to the human.

Question 2

Design an AI-powered customer support chatbot.

Accepted Answer

A customer support bot requires a hybrid search RAG pipeline for the knowledge base, a rigid intent classifier to route sensitive queries to humans, conversation state management, and strict output guardrails to prevent hallucinations. 1. **Intent Classification**: Use a small, fast model (or BERT) to classify the user's intent. If intent = 'refund' or 'angry', route immediately to a human. If intent = 'how to', route to the RAG pipeline.
2. **RAG Pipeline**: Hybrid search (Dense + BM25) over the company's help center articles.
3. **Memory**: Store the last 5-10 turns in a Redis cache using a sliding window. Periodically summarize older turns to save tokens.
4. **Guardrails**: Use an output parser or a secondary tiny LLM (Llama Guard) to ensure the bot doesn't promise free money or hallucinate policies.
5. **Analytics**: Log all interactions to a data warehouse to measure resolution rate.

Question 3

Design a document Q&A system for enterprise use.

Accepted Answer

An enterprise Document Q&A system requires robust document parsing (OCR/PDF extraction), hierarchical chunking, a scalable Vector Database with multi-tenant namespaces, and a citation-enforced generation step. 1. **Ingestion**: Use an OCR engine (like Unstructured.io) to extract text, tables, and metadata from complex PDFs.
2. **Chunking**: Use hierarchical or semantic chunking. Keep tables intact. Attach rich metadata (Doc ID, Author, Date, Tenant ID).
3. **Indexing**: Store in a Vector DB (like Milvus/Pinecone). Crucially, implement Metadata Filtering so Tenant A cannot search Tenant B's documents.
4. **Retrieval**: Use Query Expansion to handle short user queries. Retrieve top-k chunks.
5. **Generation**: Prompt the LLM strictly: 'Answer ONLY using the provided context. If the answer is not there, say I don't know. Provide citations [Doc1, Page 3].'

Question 4

Design a code generation and review system.

Accepted Answer

This system requires deep integration with CI/CD (GitHub Actions), an LLM prompted with specific static analysis rules, caching of unchanged files, and inline PR comment generation. 1. **Trigger**: System activates on a Pull Request creation.
2. **Context**: Fetch the Git diff. To provide context, fetch the specific files modified, plus the files they import (Dependency tree). 
3. **Evaluation**: Pass the diff and context to an LLM prompted to act as a 'Strict Senior Staff Engineer'. Provide a few-shot list of common company anti-patterns.
4. **Output Parsing**: Require the LLM to output a strict JSON array containing `{file, line_number, comment, severity}`.
5. **Action**: Parse the JSON and use the GitHub API to post inline comments on the PR. Only flag 'High' severity to avoid annoying developers.

Question 5

Design a content moderation system using AI.

Accepted Answer

A scalable moderation system uses a multi-tiered architecture: fast deterministic filters (Regex/Hashes) first, tiny specialized classifiers (BERT) second, and large LLMs only for highly ambiguous edge cases. Running every user message through GPT-4 for moderation is prohibitively expensive and slow. 
1. **Tier 1 (0ms)**: Blocklist regex and hash matching for known CSAM/spam.
2. **Tier 2 (10ms)**: Fast, locally hosted classification models (e.g., DistilBERT or Perspective API) trained specifically on toxicity. If the score is > 0.9, block immediately. If < 0.1, approve.
3. **Tier 3 (500ms)**: For the ambiguous middle ground (0.1 - 0.9), send the text to an LLM (or Llama Guard) with a prompt defining complex edge cases (e.g., 'Is this sarcasm or actual hate speech?').
4. **Human Review**: Send the final contested 1% to a human dashboard.

Question 6

Design a real-time AI recommendation system.

Accepted Answer

A real-time recommendation system uses a two-stage approach: a fast candidate generation step (Retrieval via Vector Search) followed by a heavy ranking step (Learning to Rank model) to sort the candidates based on user context. 1. **Embeddings**: Both Users and Items (movies, products) are embedded into the same vector space. User embeddings update periodically based on their history.
2. **Candidate Generation (Retrieval)**: When a user logs in, query the Vector DB with the User's embedding to retrieve the top 500 semantically similar items (e.g., in 20ms).
3. **Ranking**: Pass those 500 items to a Ranking Model (like XGBoost or a deep neural network). The ranker scores them based on real-time context (time of day, device, trending status) and sorts them 1 to 50.
4. **Serving**: Serve the top 50 to the UI. Cache results.

Question 7

Design a multi-modal search system (text, image, video).

Accepted Answer

A multi-modal search system uses a unified embedding model (like CLIP) to map text, images, and video frames into the same semantic space, allowing users to query the database using any modality. 1. **Ingestion**: For images, pass through CLIP to generate a vector. For video, sample 1 frame per second, pass through CLIP, and average the vectors (or store separately with timestamps). Store all vectors in a Vector DB.
2. **Querying**: If the user types text ('dog catching frisbee'), pass the text through the text-encoder of CLIP. If they upload an image, pass it through the image-encoder.
3. **Retrieval**: Perform a standard Cosine Similarity search in the Vector DB. Because text and images share the exact same dimensional space, the text query will return the image vectors.
4. **Reranking**: Use a cross-encoder to refine the top 20 results for maximum relevance.

Question 8

Design an AI-powered email assistant.

Accepted Answer

An email assistant requires an event-driven architecture connected to IMAP/webhooks, an LLM for classification and summarization, a RAG pipeline for generating replies based on past correspondence, and a draft-only safety mechanism. 1. **Ingestion**: A webhook triggers when a new email arrives. 
2. **Classification**: Pass the email to a small LLM to classify intent (Newsletter, Urgent, Support Request).
3. **RAG Context**: If it's a support request, query the Vector DB containing past sent emails to mimic the user's tone and find relevant facts.
4. **Generation**: Generate a response using a Prompt Template that strictly enforces the user's persona.
5. **Safety**: Do NOT auto-send. Save the generation to the user's 'Drafts' folder via the Gmail/Outlook API. Send a push notification for human review.

Question 9

Design a medical diagnosis assistant using AI.

Accepted Answer

A medical assistant demands maximum factual accuracy. It requires a highly specialized fine-tuned model, strict adherence to a verified medical RAG database (Pubmed/UpToDate), and absolute disclaimers regarding its non-diagnostic nature. 1. **Model**: Do not use a generic model. Use a specialized open-weight model like MedLM or heavily fine-tune a model on medical literature.
2. **Retrieval**: Use strict Hybrid Search RAG over peer-reviewed medical databases. Do not allow the model to rely on its internal pre-trained weights for medical facts.
3. **Evaluation**: Implement Self-Consistency (running the prompt 5 times and taking the majority answer) to reduce hallucination.
4. **Compliance**: System must be HIPAA compliant (no logging of PII/PHI in external APIs). Run the model locally or on a dedicated VPC.
5. **UX**: Force the user to accept a disclaimer. The prompt must include: 'You are an assistant. You cannot diagnose. End every message advising the user to see a doctor.'

Question 10

Design a fraud detection system powered by LLMs.

Accepted Answer

Fraud detection is a high-speed, structured data problem. Traditional ML (XGBoost) should be the core engine, while LLMs act as an investigative co-pilot to explain decisions and analyze unstructured text (like chat logs). 1. **Real-time Core**: For a credit card swipe (needs <50ms response), use a traditional ML anomaly detection model (Isolation Forest or XGBoost). An LLM is too slow and terrible at tabular math.
2. **Unstructured Data**: If fraud involves phishing emails or customer chat logs, pass that text through an LLM to extract intent and red flags (e.g., urgency, weird grammar).
3. **Explainability**: When the XGBoost model flags an account, feed its feature weights into an LLM. Prompt the LLM to generate a human-readable 'Fraud Investigation Report' for the human analyst.
4. **Agentic Actions**: An LLM agent can automatically draft emails requesting identity verification.

Question 11

Design an AI-powered data extraction pipeline from unstructured documents.

Accepted Answer

This pipeline uses an OCR tool to digitize the document, an LLM utilizing Structured Outputs (JSON mode) to extract specific entities, and a validation layer (Pydantic/Zod) to ensure schema adherence. 1. **Ingestion**: User uploads a messy PDF invoice. Run it through AWS Textract or Unstructured to get raw text and bounding boxes.
2. **Prompting**: Send the text to an LLM with a strict system prompt: 'Extract the Invoice Number, Total Amount, and Date. Output ONLY JSON matching this schema...'.
3. **Extraction**: Use OpenAI's `response_format: { type: 'json_object' }` to force compliance.
4. **Validation**: Pass the LLM's JSON into a Pydantic model. If it fails (e.g., date is wrong format), catch the error, feed it back to the LLM ('Fix this date format'), and retry.
5. **Storage**: Save the validated structured data into a relational PostgreSQL database.

Question 12

Design a personalized learning assistant.

Accepted Answer

A learning assistant requires a Knowledge Graph to track the student's curriculum, a stateful memory of the student's past performance, and an adaptive generation model that adjusts difficulty based on mastery. 1. **Knowledge Representation**: Use a Knowledge Graph (Neo4j) to map out subjects (e.g., Algebra -> Variables -> Equations). 
2. **State Memory**: Maintain a database tracking the student's mastery score (0-100) for each node in the graph.
3. **Adaptive Prompting**: When generating a quiz, query the student's mastery. Inject this into the system prompt: `The student has 90% mastery in Variables but 20% in Equations. Ask a question focusing on Equations using simple terms.`
4. **Evaluation**: When the student answers, use an LLM as a judge to grade the written answer, provide encouraging feedback, and update the mastery database.
5. **Safety**: Implement guardrails to prevent the bot from just giving the final answer. It must act Socratically.

Question 13

Design an AI system for automated code migration.

Accepted Answer

Automated code migration requires an AST-based chunking strategy, a multi-agent framework utilizing Plan-and-Execute, iterative compilation testing, and massive context windows to handle dependency graphs. Migrating a legacy Java 8 app to modern Go cannot be done in one prompt. 
1. **Analysis**: Agent A parses the Java repo using AST to map the dependency graph. It creates a master Plan (migrate data models first, then business logic, then API controllers).
2. **Execution**: Agent B takes one file at a time, reads the Java, and generates the Go equivalent. Crucially, it must be provided with the previously translated Go files in its context window to maintain variable consistency.
3. **Verification**: Agent C runs `go build` and `go test`. If compilation fails, the compiler error is fed back to Agent B to fix the syntax.
4. **Iteration**: This loop continues file-by-file until the entire dependency graph compiles.

AI System Design Interview Prep Portal