Advanced · Live Online · 2 days

Enterprise AI Engineering

Build a production-grade agentic system in 12 hours — RAG, knowledge graphs, agents, MCP, evaluation and production architecture. Not another chatbot course.

Live, hands-onYour own GitHub repoVerifiable certificate
Duration2 days · 6 hrs/day · 12 hours live
LevelAdvanced
FormatLive Online
Next batchDates announced soon
FeeOn request
Request a proposal
Why this bootcamp

Most GenAI courses teach you how to call an LLM. This one teaches you how to engineer an AI system.

You will not build another chatbot. Over 12 hours you take one enterprise problem through the whole engineering lifecycle — business problem, AI use case, architecture, knowledge and data layer, retrieval, agents and tools, MCP integration, guardrails and human approval, evaluation, observability, security, deployment — and end with a production-grade system you can defend.

The capstone is an Enterprise Intelligence & Action Agent: it understands a natural-language business question, retrieves from documents, databases and a knowledge graph, selects tools, runs multi-step workflows, asks for human approval before sensitive actions, answers with citations, and evaluates its own output.

The goal is AI engineering judgement, not framework memorisation. Every module keeps asking the same question: why this architecture, and not the other one? That is what separates an AI developer from an AI engineer.

What you'll build
                     USERS
                       |
                       v
                 API / UI Layer
                       |
                       v
                AI Orchestration
                       |
        +--------------+--------------+
        |              |              |
        v              v              v
      RAG            Agent        Guardrails
        |              |              |
        +--------------+--------------+
                       |
              +--------+--------+
              |        |        |
              v        v        v
            SQL      Graph     MCP
              |        |        |
              +--------+--------+
                       |
                       v
               Enterprise Systems

       +-------------------------------+
       | Evaluation / Observability    |
       | Security / Governance         |
       | Cost / Performance            |
       +-------------------------------+
Syllabus

Day by day

Day 1

Engineer the AI system

  • Enterprise AI engineering: AI application vs AI system, where the LLM actually fits, and why deterministic software practices need adapting (45 min)
  • LLMs & context engineering: tokens, context windows, system/user/tool messages, temperature, structured output, tool calling, prompt injection, model selection (60 min)
  • Build: natural language → structured business request, as validated JSON
  • RAG engineering: ingestion, chunking, metadata, embeddings, vector and hybrid indexes, top-k, filtering, reranking, context assembly, citations, grounding (90 min)
  • Build: an Enterprise Knowledge Assistant answering questions over your own documents, with citations
  • Why RAG fails: debug a deliberately broken RAG app — find the failure, identify the root cause, change the architecture, measure the improvement (60 min)
  • Knowledge graphs & enterprise context: vector vs structured retrieval, entities, relationships, ontologies, graph traversal, GraphRAG, fusing vector + graph + SQL (60 min)
  • Architecture Decision Workshop: produce a one-page Enterprise AI Architecture Decision Record, justifying every technology choice (45 min)
Day 2

Build the agentic system

  • From RAG to agents: the agent loop — plan, select tool, execute, observe, evaluate — and the critical discussion of when NOT to use an agent (60 min)
  • Tool-using agents: function calling, tool schemas and descriptions, selection, permissions, failures, retries, idempotency and side effects (75 min)
  • Build: an agent with real tools — search_documents, query_database, get_service_history, calculate_impact, request_approval
  • MCP & enterprise integration: clients, servers, tools, resources, prompts, security boundaries, and MCP vs direct APIs (60 min)
  • Agent state, memory & human-in-the-loop: short-term state vs long-term memory, memory risks, and approval gates for write and high-risk operations (60 min)
  • Break the agent: hallucinated tool calls, wrong tool selection, infinite loops, prompt injection, agent overreach — attack your own system, then build the controls (45 min)
  • Evaluation: golden datasets, retrieval precision/recall, faithfulness, answer and citation correctness, agent trajectory and tool-call accuracy, regression testing (75 min)
  • Production: tracing, token usage, cost per request, latency budgets, guardrails, security, data governance and deployment architecture
  • Final challenge: 90 minutes in teams to design and implement a complete enterprise AI system, then present and defend the architecture in five minutes
Topics covered
AI system architectureContext engineeringStructured outputModel selectionRAG architectureChunking & metadataEmbeddingsVector databasesHybrid retrievalRerankingCitations & groundingRAG failure diagnosisKnowledge graphsOntologiesGraphRAGSQL + graph + vector fusionAI agentsTool callingAgent state & memoryHuman-in-the-loopMCPGuardrailsPrompt injectionEvaluation & golden datasetsTrajectory evaluationObservability & tracingCost & latencySecurity & governanceFastAPIDockerProduction architecture
Outcomes

What you'll be able to do

Before
After
I know how to use ChatGPT
→
I can build an LLM application
I know what RAG is
→
I can diagnose and evaluate a RAG system
I know AI agents exist
→
I can design an agent with tools, state, permissions and human approval
I have heard of MCP
→
I understand how AI systems interact safely with enterprise capabilities
I built a demo
→
I can explain how I would take the system to production
Who it's for

Built for people who build software

Software EngineersMoving into AI engineering from application development
ML EngineersMoving from models into production AI systems
Data ScientistsBuilding GenAI applications beyond notebooks
AI EngineersWant stronger agent and enterprise architecture skills
Tech LeadsNeed to evaluate AI architecture and technology decisions
Solution ArchitectsWant to understand modern AI system architecture
Founders & Product EngineersWant to know what production AI actually takes

This is not…

A ChatGPT prompting courseAI theory without implementationMachine-learning mathematicsA framework tutorialA certificate without building anythingA no-code AI course
G
Your instructor

Dr Ganesh

AI Product Engineer · Generative AI, AI Systems & Software Architecture

Dr Ganesh works on practical engineering problems involving generative AI, LLM applications, AI agents, RAG systems, knowledge graphs, software architecture, code intelligence and application modernisation.

His approach is simple: don't just learn AI tools — learn how AI systems are engineered. This workshop covers practical engineering concepts and general industry knowledge, and does not expose proprietary client or employer intellectual property.

VithuPro on LinkedIn
FAQ

Questions people ask

What do I need to know before attending?

Basic programming experience. Python is recommended but not mandatory — the architecture reasoning matters more than the syntax. This is not a first programming course.

Is this a framework tutorial?

No. The workshop is framework-aware but architecture-first: you will use agent frameworks, vector databases and MCP, but the exact framework is treated as replaceable. The architecture should survive a framework change.

What will I actually have built by the end?

Two working projects and one combined system: an Enterprise Knowledge Assistant (RAG + citations + structured retrieval), an Enterprise Tool-Using Agent (tools + state + MCP), and the Enterprise Intelligence & Action Agent that combines LLM, RAG, graph, SQL, agent, MCP, guardrails, evaluation and observability.

What do I take away?

Complete source code and repository structure, architecture diagrams, the RAG and agent implementations, tool and MCP definitions, an evaluation dataset and framework, a security checklist, a production architecture template, an Architecture Decision Record template, workshop notes and a certificate of completion.

Why is so much time spent on things that fail?

Because that is the part nobody teaches. A whole module is a deliberately broken RAG app you have to diagnose, and another is attacking your own agent — hallucinated tool calls, infinite loops, prompt injection, overreach — and then building the controls. Debugging an AI system is the skill that transfers.

How is this different from an AI agents course?

Agents are one module of fifteen. The workshop covers what surrounds them in an enterprise: knowledge graphs, MCP boundaries, approval gates, evaluation, observability, cost, security and governance — the parts that decide whether a demo ever reaches production.

Will this help me in interviews?

The final session is built around defending your architecture: why RAG and not fine-tuning, how the agent selects tools, how you prevent infinite loops, how you evaluated retrieval, how you control cost, what you would change at ten million documents or a two-second latency budget. You practise answering those with a system you actually built.

Can this be run for our team?

Yes. The recommended format is 2 days × 6 hours, and it is run in-house or on campus built around your stack and your data. Get in touch for scheduling and fees.

For teams

Bring Enterprise AI Engineering to your engineering team

Delivered live online or in-house, scoped around your stack and one of your real problems. GST invoice from Vithupro Infotech Pvt. Ltd.; we can raise a proforma first if your procurement needs a PO.

Request a proposal

We reply on WhatsApp within one working day.

+91
🙌

Thanks, we've got it!

We'll message you on WhatsApp shortly.

Open WhatsApp

You should walk out able to build the thing, not just talk about it.

2 days · 6 hrs/day · 12 hours live · Live Online · On request

On requestDates announced soon
Enquire