CV/CVC AI Engineer 2026

Lộ trình Ôn thi & Chuẩn bị cho AI Engineer - VietinBank

📖 GIAI ĐOẠN 1: NỀN TẢNG (Tuần 1-2)

Python & Backend Fundamentals

Tài liệu tham khảo:

• Python: "Fluent Python" hoặc "Python Crash Course"
• FastAPI: fastapi.tiangolo.com/tutorial
• Docker: "Docker Deep Dive" by Nigel Poulton

Thực hành bắt buộc:

# 1. Xây dựng một FastAPI service đơn giản
# 2. Viết Dockerfile để containerize service
# 3. Implement REST API với authentication

Kiến thức cần nắm:

• Python advanced (async/await, decorators, type hints)
• RESTful API design principles
• Docker basics (build, run, docker-compose)
• Git workflow

Machine Learning Fundamentals

Tài liệu tham khảo:

• Andrew Ng's ML Course (Coursera) - Module 1-4
• Scikit-learn documentation

Thực hành:

• Classification, clustering, recommendation basics
• Model evaluation metrics

📖 GIAI ĐOẠN 2: LLM & GENAI CORE (Tuần 3-4)

Large Language Models Fundamentals

Tài liệu tham khảo:

1. "Generative AI with Large Language Models" - DeepLearning.AI/AWS Course
2. "Prompt Engineering Guide" - promptengineeringguide.com
3. Attention Is All You Need (Transformer paper)

Thực hành bắt buộc:

# 1. Sử dụng OpenAI API / Gemini API
# 2. Experiment với different prompt techniques:
#    - Zero-shot
#    - Few-shot
#    - Chain-of-thought
#    - Constitutional AI

from openai import OpenAI
client = OpenAI()

response = client.chat.completions.create(
    model="gpt-4",
    messages=[
        {"role": "system", "content": "You are a banking assistant."},
        {"role": "user", "content": "Explain RAG in simple terms"}
    ]
)

Concepts cần master:

• Transformer architecture (attention, tokens, context window)
• LLM APIs (OpenAI, Anthropic, Google, local models)
• Prompt engineering techniques
• Hallucination và mitigation strategies
• Token computation & cost optimization

Embeddings & Vector Search

Tài liệu tham khảo:

• "What is Embedding?" - OpenAI documentation
• FAISS documentation
• ChromaDB quickstart

Thực hành:

# Vector embedding example với ChromaDB
import chromadb
from chromadb.utils import embedding_functions

sentence_transformer = embedding_functions.SentenceTransformerEmbeddingFunction("all-MiniLM-L6-v2")

client = chromadb.Client()
collection = client.create_collection(
    name="banking_docs",
    embedding_function=sentence_transformer
)

collection.add(
    documents=["Interest rate policy document...", "Customer service procedure..."],
    ids=["doc1", "doc2"]
)

results = collection.query(
    query_texts=["What is the interest rate for savings accounts?"],
    n_results=2
)

📖 GIAI ĐOẠN 3: RAG PIPELINE (Tuần 5-6)

Retrieval-Augmented Generation

Tài liệu tham khảo:

1. RAG Paper (Lewis et al., 2020)
2. LangChain Documentation - RAG tutorials
3. LlamaIndex Documentation - RAG guides

RAG Architecture Components:

┌─────────────┐    ┌──────────────┐    ┌────────────────┐
│  Documents  │───▶│ Chunking &   │───▶│  Embedding     │
│  (Raw)      │    │ Preprocessing│    │  Generation    │
└─────────────┘    └──────────────┘    └───────┬────────┘
                                               │
                                               ▼
┌─────────────┐    ┌──────────────┐    ┌────────────────┐
│   LLM       │◀───│   Prompt     │◀───│  Vector Store  │
│  (Generate) │    │  Augment     │    │  (Retrieve)    │
└─────────────┘    └──────────────┘    └────────────────┘

Thực hành toàn diện:

# Complete RAG Pipeline với LangChain
from langchain.document_loaders import PDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain.chat_models import ChatOpenAI
from langchain.chains import RetrievalQA

# 1. Load documents
loader = PDFLoader("banking_policy.pdf")
documents = loader.load()

# 2. Chunking
splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200
)
chunks = splitter.split_documents(documents)

# 3. Embedding & Store
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(chunks, embeddings)

# 4. Retrieval & QA
llm = ChatOpenAI(model="gpt-4", temperature=0)
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever()
)

result = qa_chain({"query": "What is the minimum deposit?"})

Key RAG Strategies cần biết:

• Chunking strategies (fixed size, recursive, semantic)
• HyDE (Hypothetical Document Embeddings)
• Query expansion & reformulation
• Re-ranking (Cohere reranker)
• Hybrid search (keyword + vector)

RAG Evaluation

Metrics cần biết:

• RAGAS: Faithfulness, Answer Relevancy, Context Precision/Recall
• BLEU, ROUGE: Text similarity (baseline)
• Custom metrics: Citation accuracy, hallucination rate

📖 GIAI ĐOẠN 4: AI AGENTS (Tuần 7-8)

Agentic AI & Orchestration

Tài liệu tham khảo:

1. LangChain Agents documentation
2. "Building Effective Agents" - Anthropic guidelines
3. ReAct paper (Reasoning + Acting)

Core Agent Patterns:

# Simple ReAct Agent với LangChain
from langchain.agents import AgentType, initialize_agent, Tool
from langchain.tools import DuckDuckGoSearchRun

search = DuckDuckGoSearchRun()

tools = [
    Tool(
        name="Search",
        func=search.run,
        description="Useful for searching current information"
    )
]

agent = initialize_agent(
    tools,
    llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True
)

agent.run(
    "What is VietinBank's latest interest rate policy? "
    "Compare with ACB and VCB."
)

Patterns cần master:

1. ReAct (Reasoning + Acting): Think → Act → Observe loop
2. Plan-and-Execute: Plan first, then execute sequentially
3. Multi-Agent Systems: Specialized agents collaborate
4. Tool Integration: Connect agents with external systems

Workflow Automation:

• N8N basics (được nhắc đến trong JD)
• Integration patterns với enterprise systems

📖 GIAI ĐOẠN 5: MLOPS & PRODUCTION (Tuần 9-10)

LLM Deployment & Monitoring

Thực hành:

# Monitoring với LangSmith hoặc custom logging
import json
from datetime import datetime

class GenAIMonitor:
    def __init__(self):
        self.metrics = []
    
    def log_interaction(self, query, response, latency, tokens):
        self.metrics.append({
            "timestamp": datetime.now().isoformat(),
            "query": query,
            "response_length": len(response),
            "latency_ms": latency,
            "tokens_used": tokens,
            "feedback": None
        })
    
    def get_stats(self):
        return {
            "total_requests": len(self.metrics),
            "avg_latency": sum(m["latency_ms"] for m in self.metrics) / len(self.metrics),
            "total_tokens": sum(m["tokens_used"] for m in self.metrics)
        }

Production Considerations:

• Latency optimization: Caching, async processing, model distillation
• Cost management: Token budgeting, model routing
• Security: Input validation, output filtering, PII detection
• Compliance: Audit logging, data retention

📖 GIAI ĐOẠN 6: DỰ ÁN THỰC TẾ & ÔN TẬP (Tuần 11-12)

Project Ideas để Build Portfolio

Project 1: Internal Knowledge Base Chatbot

• RAG với company documents (mock data)
• Include citation và source tracking
• Deploy với FastAPI + Docker

Project 2: Banking Agent Assistant

• Multi-agent: balance inquiry, transaction history, loan calculator
• Integration với mock banking API
• Include error handling và escalation

Project 3: Document Processing Pipeline

• Auto-classify và extract info từ loan applications
• Use OCR + LLM + validation rules

Ôn tập Interview Prep

Coding Practice:

• LeetCode: 10-15 problems (focus: strings, arrays, graphs)
• Python-specific: decorators, generators, comprehensions
• SQL: joins, aggregations, window functions

System Design Practice:

• Design a RAG system for banking documents
• Design a customer service chatbot
• Design an AI agent for loan processing

Mock Interview:

• Practice với friend hoặc sử dụng Pramp/Interviewing.io
• Time yourself: 45 phút cho system design

📚 TÀI LIỆU THAM KHẢO TỔNG HỢP

Courses & Certifications:

Communities & Newsletters:

• The Batch (DeepLearning.AI) - Weekly newsletter
• Import AI (Nathan Benaich) - Weekly
• Hugging Face Daily Papers
• r/MachineLearning, r/LocalLLaMA

Vietnamese AI Community:

• Vietnam AI Alliance
• VietnamML Community
• AI Vietnam Group (Facebook)