Capgemini: GenAI Engineer, 5 Reports (2025)

• ANN (MLP): layers of neurons with non-linear activations, trained by backpropagation. They have no memory of sequence order.
• RNN: reuses one cell across time steps with a hidden state hₜ = f(W·xₜ + U·hₜ₋₁). It suffers from vanishing or exploding gradients on long sequences.
• LSTM: adds a cell state plus forget, input and output gates that control what to keep, so it remembers longer. GRU is a lighter version.
• Why Transformers won:
• Self-attention links any two tokens directly.
• Training is fully parallel rather than step by step.
• They scale far better, which made pre-trained LLMs possible.

• Zero-shot: a clear instruction with a role, the task, constraints and the output format.
• Few-shot: 2 to 5 examples that show the exact pattern, which is great for classification or extraction.
• Chain-of-thought: ask the model to reason step by step. Use it for maths and logic, and hide the reasoning from end users if needed.
• Self-consistency: sample several reasoning paths and take a majority vote.
• ReAct: reasoning plus tool calls, which is the basis of agents.
• Structured output: a JSON schema, delimiters around the context, and "answer only from the context, else say I don't know".
• Always evaluate prompts against a small labelled set rather than judging by eye.

• Hosted: GPT-4o / 4.1 / o-series, Claude, Gemini.
• Open-weight: Llama 3.x, Mistral/Mixtral, Qwen, Phi and Gemma.
• Selection criteria:
• Task quality on your evaluation set
• Context length
• Latency and cost per 1k tokens
• Data privacy (on-premises vs API)
• Licensing
• Tool-calling and JSON support
• Language support (Hindi or other regional languages)
• Common pattern: a big model for complex reasoning, a small or cheap model for classification and routing, and an open model self-hosted when data cannot leave the network.

• What it stores: embeddings (dense vectors) together with metadata, and it returns the nearest neighbours for a query vector.
• Similarity: usually cosine or dot product (L2 is also used).
• ANN indexes make search fast at scale:
• HNSW: a graph index with high recall that uses a lot of memory.
• IVF: clustering; it searches only the nearest clusters.
• PQ: product quantization, which compresses vectors.
• Examples:
• Libraries: FAISS.
• Databases: Chroma, Pinecone, Weaviate, Qdrant, Milvus.
• Extensions: pgvector, Azure AI Search.
• Features to mention: metadata filtering, hybrid (keyword + vector) search, multi-tenancy, incremental upserts.

• ollama pull llama3.1:8b, then ollama run llama3.1. It serves a local REST API on port 11434, which LangChain uses through ChatOllama.
• Why:
• Data privacy: nothing leaves the machine.
• No API cost.
• Offline development.
• Quick testing of open models.
• Limits: quality is below frontier models, it is bound by your hardware, and it is not built for high-concurrency serving. For production throughput use vLLM or TGI.

• Definition: storing weights (and sometimes activations) in fewer bits, such as FP16 → INT8 → 4-bit.
• Gains: about 2 to 4 times less memory, faster inference, and larger models fit on smaller GPUs or even laptops.
• Methods:
• Post-training quantization: GPTQ, AWQ, bitsandbytes NF4, and GGUF (llama.cpp / Ollama).
• QLoRA: fine-tuning adapters on top of a 4-bit base model.
• Cost: a small loss of accuracy, larger at 3 bits or fewer and on reasoning-heavy tasks. Always re-run your evaluation set after quantizing.

• Ingestion: load documents → clean them → chunk them (for example 500 to 1,000 tokens with overlap) → embed → store in the vector DB with metadata.
• Query:
• Embed the question and retrieve the top-k chunks (hybrid search plus a re-ranker for quality).
• Build the prompt with the context, then generate a cited answer.
• Evaluation:
• Retrieval: recall@k and MRR.
• Generation: faithfulness, answer relevance and context precision (RAGAS).
• Why RAG rather than fine-tuning for knowledge: the data stays fresh, answers cite sources, it is cheaper, and access control can be applied per document.

• Definition: systems where an LLM decides the next step. It plans, calls tools or APIs, observes the result and iterates, often with memory and several specialised agents.
• Example: an invoice-processing agent. 1. Extract the fields with a vision LLM. 2. Validate them against the ERP API. 3. Flag a mismatch to a human. 4. Post the entry.
• Frameworks: LangGraph, CrewAI, AutoGen, Semantic Kernel, OpenAI Agents SDK.
• Must-haves: step limits, typed tools, approval for actions with side effects, and tracing.

• FastAPI service → Docker image → Azure Container Apps, AKS or ECS.
• Keep secrets in Key Vault.
• Use a managed vector store and async endpoints with streaming.
• Ingestion pipeline as a scheduled job.
• CI/CD with tests plus an evaluation gate.
• Monitoring: latency, tokens, cost, user feedback and traces.
• Release: canary, with a rollback plan.
• Tip: deploy even a hobby project (Azure free tier, Render or Hugging Face Spaces) so you can say "I deployed it" truthfully. This is exactly what one rejected candidate was missing.

def reverse_words(s: str) -> str:
    return " ".join(w[::-1] for w in s.split())

print(reverse_words("gen ai engineer"))  # neg ia reeenigne

• split() with no argument handles multiple spaces. The function is O(n) in time and space.
• Explain edge cases aloud (empty string, punctuation). Interviewers at this level care about clarity, not tricks.