Skip to main content
DevHives
Course

AI Engineer Course: LLMs, AI Agents and MCP

  • 24 weeks
  • 6 phases
  • Beginner to Advanced

Learn to build with large language models — prompting, RAG, AI agents, MCP servers and the terminal tools professionals use every day — from your first API call to a deployed, evaluated AI product.

Download brochure (PDF)

What you will learn

  • LLM fundamentals
  • Model selection
  • Prompt APIs
  • Token budgeting
  • Prompt engineering
  • Structured output
  • Tool calling
  • Streaming
  • Embeddings
  • Vector databases
  • RAG
  • Citation quality
  • AI agents
  • Agent SDKs
  • Multi-agent design
  • Guardrails
  • MCP
  • Claude Skills
  • Claude Code
  • Codex
  • Terminal workflows
  • LLM evaluation
  • Observability
  • Context engineering
  • Deployment

Where this course can take you

The programme prepares you for roles that build products on top of foundation models:

  • AI engineer
  • LLM application engineer
  • AI product engineer
  • Agent / automation engineer
  • AI solutions engineer

Salary in India

Public salary reports do not sample the job title “AI engineer” separately. The closest sourced roles are machine-learning engineers and data scientists, so the bands below are indicative ranges, not an AI salary promise.

Indicative cash CTC in Bengaluru, in lakh a year, for the closest sourced roles
Role0–3 years3–7 years
Machine-learning engineer (ML)₹10–17 lakh₹22–38 lakh
Data scientist₹8–15 lakh₹18–34 lakh

Bengaluru cash CTC (base plus variable), in lakh a year. Source: kaam.work, India Tech Salary Report, 28 April 2026. Secondary blog that compiles Michael Page 2026, Deloitte, nasscom 2025 and SalaryExpert modelled data. No sample sizes. Cash CTC means base plus variable, Bengaluru.

Pay depends on the city, the company and the role you are hired for. The course prepares you to apply and interview; it does not promise a salary.

Read the AI engineer fresher salary guide (India vs the US)Work out what an offer leaves in hand

AI engineer roadmap: what you know after each month

Six phases, one month each. Every month ends with a project you can put in a portfolio — the same phases as the full curriculum further down this page.

  1. Month 1

    AI Engineering Foundations & LLMs

    4 weeks · weeks 1–4

    By the end of this month you can work with:

    • LLM fundamentals
    • Model selection
    • Prompt APIs
    • Token budgeting

    You build: Build a model-comparison CLI that sends one prompt to two providers and logs tokens, cost and latency side by side.

  2. Month 2

    Prompting, Structured Outputs & Tool Calling

    4 weeks · weeks 5–8

    By the end of this month you can work with:

    • Prompt engineering
    • Structured output
    • Tool calling
    • Streaming

    You build: Build a structured-data extraction service that turns unstructured text into validated JSON with retries and a streaming progress UI.

  3. Month 3

    Embeddings, Vector Search & RAG

    4 weeks · weeks 9–12

    By the end of this month you can work with:

    • Embeddings
    • Vector databases
    • RAG
    • Citation quality

    You build: Build a RAG assistant over your own docs that answers with citations and refuses when the retrieved context is too weak.

  4. Month 4

    AI Agents & Multi-Agent Workflows

    4 weeks · weeks 13–16

    By the end of this month you can work with:

    • AI agents
    • Agent SDKs
    • Multi-agent design
    • Guardrails

    You build: Build a research agent that plans, calls tools, pauses for approval on writes, and stops at a hard cost budget.

  5. Month 5

    MCP, Claude Skills & the Agent Toolchain

    4 weeks · weeks 17–20

    By the end of this month you can work with:

    • MCP
    • Claude Skills
    • Claude Code
    • Codex
    • Terminal workflows

    You build: Build an MCP server that exposes a real API to an agent, package a reusable Skill, and drive it from the terminal (Claude Code or Codex).

  6. Month 6

    Evaluation, Observability & Production

    4 weeks · weeks 21–24

    By the end of this month you can work with:

    • LLM evaluation
    • Observability
    • Context engineering
    • Deployment

    You build: Deploy an evaluated, observable AI application with a regression suite, a cost dashboard and a written case study for your portfolio.

Course curriculum

6 phases over 24 weeks, 18 topic areas and 6 hands-on builds. Open any phase to see what it covers.

What an AI Engineer Does

  • AI engineer vs ML engineer vs data scientist
  • The product-development impact of foundation models
  • AI vs AGI, and what the course does not promise
  • Roles and responsibilities on a real AI team

How LLMs Work

  • Tokens, context windows and why context is a budget
  • Inference vs training, and pre-trained models
  • Sampling parameters: temperature, top-k and top-p
  • Closed vs open-source models; choosing a model by job

The Model Landscape

  • Anthropic Claude, OpenAI GPT and o-series, Google Gemini
  • Meta Llama, Mistral, Cohere and open-weight options
  • Running models locally with Ollama and LM Studio
  • Cost, latency and data-handling trade-offs

You'll build: Build a model-comparison CLI that sends one prompt to two providers and logs tokens, cost and latency side by side.

Prompt Engineering

  • System prompts, roles, constraints and refusal behaviour
  • Zero-shot, few-shot and chain-of-thought prompting
  • ReAct-style reasoning for tool-driven tasks
  • Robust prompts that survive messy user input

Structured Outputs

  • JSON schema and typed responses
  • Validation, retries and repair loops
  • Streaming responses without breaking the UI
  • Prompt caching for repeated context

Function & Tool Calling

  • Defining tools the model can call
  • Tool results, errors and multi-step calls
  • Constraining inputs and outputs
  • Adding end-user IDs for safety and attribution

You'll build: Build a structured-data extraction service that turns unstructured text into validated JSON with retries and a streaming progress UI.

Embeddings

  • What an embedding represents and how similarity works
  • Semantic search, classification and recommendations
  • Embedding model choices and dimensions
  • Batch vs real-time embedding

Vector Databases

  • Indexing embeddings and similarity search
  • pgvector, Chroma, Pinecone, Qdrant and FAISS
  • Filtering, namespaces and metadata
  • MongoDB Atlas and Supabase as managed options

Retrieval-Augmented Generation

  • Chunking strategies and document preparation
  • Retrieve, rerank, generate — and cite
  • RAG vs fine-tuning: when each is the right tool
  • Evaluating retrieval quality separately from answers

You'll build: Build a RAG assistant over your own docs that answers with citations and refuses when the retrieved context is too weak.

The Agent Loop

  • Observe, plan, act and reflect
  • Manual agent implementations vs agent SDKs
  • Memory, state and long-running tasks
  • Approval gates and permission boundaries

Agent SDKs

  • Claude Agent SDK and the Claude Messages API
  • OpenAI Agents SDK and compatible APIs
  • Multi-agent patterns: supervisor, hand-off, debate
  • Cost budgets and step limits

Safety & Guardrails

  • Prompt injection and indirect injection through tools
  • Constraining what an agent may read or write
  • Content moderation and human review
  • Adversarial testing before launch

You'll build: Build a research agent that plans, calls tools, pauses for approval on writes, and stops at a hard cost budget.

Model Context Protocol (MCP)

  • Hosts, clients and servers — who talks to whom
  • Data layer and transport layer
  • Building an MCP server and an MCP client
  • Connecting a local server vs a remote server

Claude Skills & Agent Configuration

  • Packaging repeatable instructions and assets as a Skill
  • Project instructions, tools and permissions
  • When a Skill beats a longer prompt
  • Versioning and sharing agent configuration

Terminal vs Web Interfaces

  • What terminal agents do that a chat UI cannot
  • Claude Code vs Codex: workflows, strengths, trade-offs
  • Reading, editing and running a real codebase
  • Choosing the right interface for the task

You'll build: Build an MCP server that exposes a real API to an agent, package a reusable Skill, and drive it from the terminal (Claude Code or Codex).

LLM Evaluation

  • Deterministic, model-based and human evaluation
  • LLM-as-a-judge: when it is useful and when it lies
  • Evaluation metrics for RAG and agents
  • Regression testing prompts and models

Observability & Cost

  • Tracing and logging every model call
  • Cost and latency monitoring
  • Production monitoring and alerting
  • LangSmith, Langfuse, Helicone and Arize

Ship It

  • Context engineering and context failure modes
  • Deploying the API and the UI together
  • Secrets, rate limits and abuse controls
  • Portfolio, code review and interview preparation

You'll build: Deploy an evaluated, observable AI application with a regression suite, a cost dashboard and a written case study for your portfolio.

What you need to start

  • Basic computer knowledge and enthusiasm to learn. No prior programming experience is required — we start from the fundamentals and build up gradually.
  • Around 2–3 hours a day. Sessions are live, and every one is recorded with lifetime access if you miss it.
  • Live sessions and 1:1 mentorship run in Bengali, Hindi or English. Course material is in English.

Frequently asked questions

Everything you need to know before you enroll. Still unsure? Talk to an advisor.

Other tracks

Your next chapter starts here

Ready to start building?

Explore the curriculum, preview a project, or talk through the right course for your goals.

Chat on WhatsApp