> ## Documentation Index
> Fetch the complete documentation index at: https://notes.kodekloud.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Course Introduction
> Hands-on course teaching deployment, management, and observability of AI agents on Kubernetes with KAgent, KMCP/MCP, system prompts, and integrations like Slack and AWS
The AI landscape is evolving quickly: agents are no longer limited to answering questions — they can take actions, connect to tools, and automate workflows. KAgent is a platform for running and managing these AI agents inside Kubernetes clusters. This course shows you how to design, deploy, and operate AI agents on Kubernetes using KAgent, KMCP/MCP, and related tooling.
You will learn practical, production-focused topics:
* How to install and operate KAgent in Kubernetes.
* How agents communicate using the A2A (agent-to-agent) protocol.
* How to build and run MCP servers and integrate them with agents.
* How to create system prompts, define agents declaratively, and debug agent behavior using observability tools like Jaeger.
* How to connect external tools and services (for example, Slack, AWS CloudWatch, Billing) to your agents.
Recommended prerequisites: basic Kubernetes knowledge (kubectl), familiarity with YAML manifests, and experience with Python or other scripting languages for building local integrations.
We begin with an overview of KAgent and a hands-on lab that walks you through the KAgent portal and agent lifecycle.
This section gives you a bird's-eye view of the KAgent dashboard and how to interact with agents and tools through the UI. Next, we explain A2A — the secure agent-to-agent communication protocol that KAgent uses for agent interactions and orchestration.
We then cover KAgent architecture and installation: core components, controllers, sidecar agents, and recommended deployment patterns. After installation you will validate the deployment and inspect running pods.
Example: after a successful installation you should see the KAgent-related pods running in the `kagent` namespace:
```bash theme={null}
# kubectl get pods -n kagent
NAME READY STATUS RESTARTS AGE
argo-rollouts-conversion-agent-6b75f48f84-skzsc 1/1 Running 0 40s
cilium-debug-agent-5c7798b559-9bbzh 1/1 Running 0 40s
cilium-manager-agent-5dc4964899-2vkn4 1/1 Running 0 40s
cilium-policy-agent-595f585896-hsmqb 1/1 Running 0 39s
helm-agent-66d7fd5fb8-dvbr6 1/1 Running 0 40s
istio-agent-557f7c74d9-tcspp 1/1 Running 0 39s
k8s-agent-76755c85bd-7wcvt 1/1 Running 0 40s
kagent-controller-6886fc4f5c-wn2xm 1/1 Running 0 97s
kagent-grafana-mcp-5cc85fd598-hw6bk 1/1 Running 0 97s
kagent-kmcp-controller-manager-76645f577f-n2r5v 1/1 Running 0 97s
kagent-querydoc-5f6fd94c98-64kxn 1/1 Running 0 97s
kagent-tools-56c49d7d4d-6h8zg 1/1 Running 0 97s
kagent-ui-59d5bbd564-r7j5q 1/1 Running 0 97s
kgateway-agent-d97c5f7d-5qg2c 1/1 Running 0 40s
observability-agent-55d64bd489-987hm 1/1 Running 0 40s
promql-agent-56c56b98bd-xvlzw 1/1 Running 0 39s
```
Once the foundation is ready, the course introduces KMCP and MCP servers. You will install a KMCP control plane and deploy one or more MCP servers (for example, an AWS-hosted MCP), enabling agents to query dynamic data sources or external APIs through the Model Context Protocol (MCP).
You will also build a custom MCP server. Example use case: agents fetch real-time cryptocurrency prices via an MCP endpoint so the agent can make data-driven decisions based on live market data.
Example lab output when starting local components (CLI header):
```bash theme={null}
Welcome to the KodeKloud Hands-On lab
KodeKloud
All rights reserved
controlplane ~ via 🐍 v3.10.12
```
The course covers system prompts and prompt engineering for agents: how to craft system-level prompts, structure instructions for predictable behavior, and manage prompt templates used by multiple agents. You will also learn to declare agents using YAML manifests for reproducible deployments.
Observability and debugging are core topics. We demonstrate tracing and telemetry with Jaeger to analyze end-to-end agent workflows, locate failures, and optimize performance. Example Jaeger Helm values for an all-in-one development deployment:
```yaml theme={null}
# jaeger.yaml - Jaeger Helm values for development (all-in-one)
provisionDataStore:
cassandra: false
allInOne:
enabled: true
storage:
type: memory
agent:
enabled: false
collector:
enabled: false
query:
enabled: false
```
Course structure (high-level):
| Module | Topics covered | Outcome |
| ------------------------- | ----------------------------------------------------- | -------------------------------------------- |
| KAgent Overview | Architecture, dashboard, A2A protocol | Understand KAgent components and UI |
| Installation & Validation | Helm manifests, kubectl checks, runtime pods | Deploy KAgent to a cluster and validate pods |
| KMCP & MCP Servers | KMCP control plane, MCP server deployment, custom MCP | Build and connect MCP servers to agents |
| Agent Development | YAML manifests, system prompts, integrations | Create declarative and BYO agents |
| Observability & Debugging | Jaeger tracing, logs, metrics | Trace agent workflows and debug issues |
| Integrations & Labs | Slack bot, AWS CloudWatch, LangGraph example | Connect agents to real tools and services |
Key components used in labs:
| Component | Purpose | Notes / Examples |
| ----------------------- | --------------------------------------------------- | -------------------------------------------------------------------------- |
| SLACK APP | External integration for notifications and commands | Create at `api.slack.com/apps`; needs `SLACK_BOT_TOKEN`, `SLACK_APP_TOKEN` |
| SLACK BOT (Python Bolt) | Local development bridge to KAgent | Runs `python main.py`, listens for `/mykagent`, formats Block Kit |
| KAGENT AGENT | Deployed in Kubernetes cluster | Declarative YAML manifests manage agent lifecycle |
| MCP Server | Provides contextual data to agents | Can be AWS-hosted or self-hosted; serve model context to LLMs |
| KMCP | Control plane for MCP servers | Coordinates MCP discovery and access |
Security note: never commit tokens or secrets (for example `SLACK_BOT_TOKEN`, `SLACK_APP_TOKEN`) into source control. Use Kubernetes Secrets, environment variables at runtime, or a secrets manager.
Example environment variables used in labs:
```bash theme={null}
export SLACK_BOT_TOKEN="xoxb-..."
export SLACK_APP_TOKEN="xapp-1-..."
export KAGENT_A2A_URL="http://127.0.0.1:8083/api/a2a/kagent/my-k8s-agent/"
```
Final hands-on lab: you will combine KAgent, MCP servers, system prompts, and observability to build a complete, deployable AI agent that integrates with external services like Slack and AWS CloudWatch. The course concludes with short quizzes after each section to reinforce key concepts.
Links and references:
* [LangGraph course](/user/courses/langgraph)
* [AWS CloudWatch course](/user/courses/aws-cloudwatch)
* [Jaeger Tracing](https://www.jaegertracing.io/)
* [Kubernetes Concepts](https://kubernetes.io/docs/concepts/overview/what-is-kubernetes/)
By the end of this course you will be able to design, deploy, and operate AI agents on Kubernetes with KAgent — managing communication, observability, and integrations in production-grade environments.