diff --git a/public/images/jaeger-landing.png b/public/images/jaeger-landing.png
index e10d6809..b65b5102 100644
Binary files a/public/images/jaeger-landing.png and b/public/images/jaeger-landing.png differ
diff --git a/public/images/jaeger-trace.png b/public/images/jaeger-trace.png
index 1092b06f..f51db3b0 100644
Binary files a/public/images/jaeger-trace.png and b/public/images/jaeger-trace.png differ
diff --git a/public/images/k8s-agent-first-chat.png b/public/images/k8s-agent-first-chat.png
new file mode 100644
index 00000000..eed56e2d
Binary files /dev/null and b/public/images/k8s-agent-first-chat.png differ
diff --git a/public/images/k8s-agent-query-light.png b/public/images/k8s-agent-query-light.png
new file mode 100644
index 00000000..711724f9
Binary files /dev/null and b/public/images/k8s-agent-query-light.png differ
diff --git a/public/images/k8s-agent-results.png b/public/images/k8s-agent-results.png
new file mode 100644
index 00000000..46c61133
Binary files /dev/null and b/public/images/k8s-agent-results.png differ
diff --git a/public/images/kagent-landing.png b/public/images/kagent-landing.png
index 876935bc..cfce95b1 100644
Binary files a/public/images/kagent-landing.png and b/public/images/kagent-landing.png differ
diff --git a/public/images/kagent-memory.png b/public/images/kagent-memory.png
new file mode 100644
index 00000000..c9be94a3
Binary files /dev/null and b/public/images/kagent-memory.png differ
diff --git a/public/images/kagent-new.png b/public/images/kagent-new.png
index 599d13d8..f31b47fb 100644
Binary files a/public/images/kagent-new.png and b/public/images/kagent-new.png differ
diff --git a/public/images/kagent-tools-add.png b/public/images/kagent-tools-add.png
new file mode 100644
index 00000000..3d1c1734
Binary files /dev/null and b/public/images/kagent-tools-add.png differ
diff --git a/public/images/kagent-wizard-finish.png b/public/images/kagent-wizard-finish.png
new file mode 100644
index 00000000..8edcd278
Binary files /dev/null and b/public/images/kagent-wizard-finish.png differ
diff --git a/public/images/kagent-wizard-review.png b/public/images/kagent-wizard-review.png
new file mode 100644
index 00000000..7230db5e
Binary files /dev/null and b/public/images/kagent-wizard-review.png differ
diff --git a/public/images/kagent-wizard.png b/public/images/kagent-wizard.png
new file mode 100644
index 00000000..e00bcd51
Binary files /dev/null and b/public/images/kagent-wizard.png differ
diff --git a/public/sitemap.xml b/public/sitemap.xml
index 538fc5b5..9dd2bfd1 100644
--- a/public/sitemap.xml
+++ b/public/sitemap.xml
@@ -2,504 +2,497 @@
https://kagent.dev/agents
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/blog
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/community
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kagent/concepts/agents
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kagent/concepts/architecture
- 2025-08-13
- weekly
- 0.8
-
-
-
- https://kagent.dev/docs/kagent/concepts/memory
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kagent/concepts
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kagent/concepts/tools
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kagent/examples/a2a-agents
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kagent/examples/discord-a2a
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kagent/examples/documentation
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kagent/examples
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kagent/examples/slack-a2a
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kagent/getting-started/first-agent
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kagent/getting-started/first-mcp-tool
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kagent/getting-started
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kagent/getting-started/quickstart
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kagent/getting-started/system-prompts
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kagent/getting-started/tracing
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kagent/introduction/installation
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kagent/introduction
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kagent/introduction/what-is-kagent
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kagent
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kagent/resources/faq
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kagent/resources
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kagent/resources/release-notes
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kagent/resources/troubleshooting
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kagent/supported-providers/anthropic
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kagent/supported-providers/azure-openai
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kagent/supported-providers/custom-models
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kagent/supported-providers/google-vertexai
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kagent/supported-providers/ollama
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kagent/supported-providers/openai
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kagent/supported-providers
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kmcp/deploy/install-controller
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kmcp/deploy
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kmcp/deploy/server
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kmcp/develop/fastmcp-python
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kmcp/develop/mcp-go
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kmcp/develop
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kmcp/introduction
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kmcp
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kmcp/quickstart
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kmcp/reference/kmcp-add-tool
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kmcp/reference/kmcp-build
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kmcp/reference/kmcp-deploy
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kmcp/reference/kmcp-init
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kmcp/reference/kmcp-install
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kmcp/reference/kmcp-run
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kmcp/reference/kmcp-secrets
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kmcp/reference
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs/kmcp/secrets
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/docs
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/page.tsx
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/tools
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/agents/argo-rollouts-conversion-agent
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/agents/cilium-crd-agent
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/agents/helm-agent
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/agents/istio-agent
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/agents/k8s-agent
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/agents/kgateway-agent
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/agents/observability-agent
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/agents/promql-agent
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/tools/istio
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/tools/kubernetes
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/tools/prometheus
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/tools/documentation
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/tools/helm
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/tools/argo
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/tools/grafana
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/tools/other
- 2025-08-13
+ 2025-08-14
weekly
0.8
https://kagent.dev/tools/cilium
- 2025-08-13
+ 2025-08-14
weekly
0.8
diff --git a/src/app/docs/kagent/concepts/agents/page.mdx b/src/app/docs/kagent/concepts/agents/page.mdx
index 65ac6dde..2a5acb37 100644
--- a/src/app/docs/kagent/concepts/agents/page.mdx
+++ b/src/app/docs/kagent/concepts/agents/page.mdx
@@ -56,9 +56,13 @@ Here's how you could reference an existing agent (`promql-agent`) as a tool:
```yaml
...
# Referencing existing tools
+ tools:
- type: McpServer
mcpServer:
- toolServer: kagent-tool-server
+ name: kagent-tool-server
+ # Or a Kubernetes Service with "appProtocol: mcp", labels, and annotations for MCP
+ # Or an MCPServer
+ kind: RemoteMCPServer
toolNames:
- k8s_get_resources
- k8s_get_available_api_resources
diff --git a/src/app/docs/kagent/concepts/architecture/page.mdx b/src/app/docs/kagent/concepts/architecture/page.mdx
index 0c573b80..57a2749b 100644
--- a/src/app/docs/kagent/concepts/architecture/page.mdx
+++ b/src/app/docs/kagent/concepts/architecture/page.mdx
@@ -4,6 +4,8 @@ pageOrder: 1
description: "Explore the high-level architecture of kagent, including its core components like the Controller, App/Engine, CLI, and Dashboard."
---
+import { Tabs, Tab } from '@/components/mdx/tabs';
+
export const metadata = {
title: "kagent architecture",
description: "Explore the high-level architecture of kagent, including its core components like the Controller, App/Engine, CLI, and Dashboard.",
@@ -47,6 +49,29 @@ The CLI offers a way to interact with the engine for those who prefer a CLI inte
Kagent dashboard provides a web interface for managing and working with AI agents. Is it the simplest way to get started with kagent.
+
+
+
+ ```shell
+ kagent dashboard
+ ```
+
+
+
+1. Enable port-forwarding on the `kagent` service.
+
+ ```shell
+ kubectl -n kagent port-forward svc/kagent 8001:80
+ ```
+
+2. Open your browser to [http://localhost:8001](http://localhost:8001).
+
+
+
+
## Next Steps
- Try [building your own agent](/docs/kagent/getting-started/first-agent)
diff --git a/src/app/docs/kagent/concepts/memory/page.mdx b/src/app/docs/kagent/concepts/memory/page.txt
similarity index 96%
rename from src/app/docs/kagent/concepts/memory/page.mdx
rename to src/app/docs/kagent/concepts/memory/page.txt
index 2fdd8ede..fcfcc105 100644
--- a/src/app/docs/kagent/concepts/memory/page.mdx
+++ b/src/app/docs/kagent/concepts/memory/page.txt
@@ -31,7 +31,7 @@ kubectl create secret generic pinecone-credentials -n kagent --from-literal PINE
Once the API key is in place, you can use the Memory CRD to configure the memory for your agent. For example:
```yaml
-apiVersion: kagent.dev/v1alpha1
+apiVersion: kagent.dev/v1alpha2
kind: Memory
metadata:
name: my-pinecone-memory
@@ -39,7 +39,7 @@ metadata:
spec:
provider: Pinecone
# The secret containing the API key for the vector database
- apiKeySecretRef: pinecone-credentials
+ apiKeySecret: pinecone-credentials
# The key in the secret containing the API key
apiKeySecretKey: PINECONE_API_KEY
pinecone:
@@ -62,7 +62,7 @@ You can use Kubernetes CLI to create the memory.
To attach memory to an agent, you can use the `memory` field in the agent spec. Note that the field is an array, so you can attach multiple memories to an agent:
```yaml
-apiVersion: kagent.dev/v1alpha1
+apiVersion: kagent.dev/v1alpha2
kind: Agent
metadata:
name: memoryagent
diff --git a/src/app/docs/kagent/concepts/tools/page.mdx b/src/app/docs/kagent/concepts/tools/page.mdx
index bd359170..6730a8b1 100644
--- a/src/app/docs/kagent/concepts/tools/page.mdx
+++ b/src/app/docs/kagent/concepts/tools/page.mdx
@@ -35,16 +35,3 @@ MCP stands for [Model Context Protocol](https://modelcontextprotocol.io/introduc
## HTTP Tools
HTTP tools are another way to bring external tools into kagent. Simply put, given a URL and a schema, kagent will send the user query to the URL and return the response. Kagent has the ability to discovery HTTP tools from services running in the cluster, assuming they are OpenAPI Compliant.
-
-## Tool Discovery
-
-Tool Discovery is one of the most powerful features of kagent. It allows you to discover tools from the cluster and make them available to your agents automatically.
-
-Simply annotate a service with the following annotation:
-
-```yaml
-annotations:
- kagent.dev/tool.type: "openapi" | "mcp"
-```
-
-Once annotated, kagent will automatically discover all tools from the service and make them available to your agents.
diff --git a/src/app/docs/kagent/examples/a2a-agents/page.mdx b/src/app/docs/kagent/examples/a2a-agents/page.mdx
index f4ba4c64..3a973d0f 100644
--- a/src/app/docs/kagent/examples/a2a-agents/page.mdx
+++ b/src/app/docs/kagent/examples/a2a-agents/page.mdx
@@ -16,173 +16,229 @@ Every AI agent created with kagent implements the [A2A protocol](https://develop
Let's look at how this works in kagent!
-## Create an AI agent that supports A2A
+## Prerequisites
-We'll create a simple agent (`k8s-a2a-agent`) that can retrieve resources from a Kubernetes cluster. Note the definition of the agent follows the Agent CRD with the `a2aConfig` section added that describes the skills the agent can perform. You can follow the [quick start](/docs/kagent/getting-started/quickstart) to install kagent and then apply the following definition to your cluster:
+Install kagent by following the [quick start](/docs/kagent/getting-started/quickstart) guide.
+
+## Creating an AI agent that supports A2A
+
+Create a simple agent (`k8s-a2a-agent`) that can retrieve resources from a Kubernetes cluster. Note the definition of the agent follows the Agent CRD with the `a2aConfig` section added that describes the skills the agent can perform.
```yaml
-apiVersion: kagent.dev/v1alpha1
+kubectl apply -f - <Note that you could also expose the A2A endpoint publicly by using a gateway.
+
+ ```bash
+ kubectl port-forward svc/kagent-controller 8083:8083 -n kagent
+ ```
+
+2. To test that the agent is available and has an agent card, send a request to the `.well-known/agent.json` endpoint. Note the API endpoint follows the pattern `/api/a2a/{namespace}/{agent-name}/.well-known/agent.json`.
+
+ ```bash
+ curl localhost:8083/api/a2a/kagent/k8s-a2a-agent/.well-known/agent.json
+ ```
+
+ Example output: This JSON object describes the agent as per the [A2A protocol](https://a2a.guide/protocol/agent-card.html).
+
+ ```json
+ {
+ "name": "k8s_a2a_agent",
+ "description": "An example A2A agent that knows how to use Kubernetes tools.",
+ "url": "http://127.0.0.1:8083/api/a2a/kagent/k8s-a2a-agent/",
+ "version": "",
+ "capabilities": {
+ "streaming": true,
+ "pushNotifications": false,
+ "stateTransitionHistory": true
+ },
+ "defaultInputModes": [
+ "text"
+ ],
+ "defaultOutputModes": [
+ "text"
+ ],
+ "skills": [
+ {
+ "id": "get-resources-skill",
+ "name": "Get Resources",
+ "description": "Get resources in the Kubernetes cluster",
+ "tags": [
+ "k8s",
+ "resources"
+ ],
+ "examples": [
+ "Get all resources in the Kubernetes cluster",
+ "Get the pods in the default namespace",
+ "Get the services in the istio-system namespace",
+ "Get the deployments in the istio-system namespace",
+ "Get the jobs in the istio-system namespace",
+ "Get the cronjobs in the istio-system namespace",
+ "Get the statefulsets in the istio-system namespace"
+ ],
+ "inputModes": [
+ "text"
+ ],
+ "outputModes": [
+ "text"
+ ]
+ }
+ ]
+ }
+ ```
+
+## Invoking the agent
+
+You can invoke the agent in several ways, including the kagent dashboard, kagent CLI, and the A2A host CLI.
+
+### Dashboard
+
+Launch the dashboard with `kagent dashboard`, find your `k8s-a2a-agent`, and start chatting. For complete steps, see the [Your First Agent](/docs/kagent/getting-started/first-agent) guide.
+
+### kagent CLI
+
+To use the kagent CLI, make sure that the controller is still being port-forwarded.
+
+Then, use the invoke command. For more options, run `kagent help invoke`.
+
+```shell
+kagent invoke --agent k8s-a2a-agent --task "Get the pods in the kagent namespace"
```
->Note that you could also expose the A2A endpoint publicly by using a gateway.
-
-To test that the agent is available and has an agent card, we can send a request to the `.well-known/agent.json` endpoint. Note the API endpoint follows the pattern `/api/a2a/{namespace}/{agent-name}/.well-known/agent.json`.
-
-Let's send a request to the endpoint:
-
-```bash
- curl localhost:8083/api/a2a/kagent/k8s-a2a-agent/.well-known/agent.json
-```
+Example output: The output includes both the response as well as the details of the response. The formatting is in JSON but can be quite long, depending on the call and the agent configuration.
-The output will be a JSON object that describes the agent as per the [A2A protocol](https://a2a.guide/protocol/agent-card.html).
```json
{
- "name": "k8s-a2a-agent",
- "description": "An example A2A agent that knows how to use Kubernetes tools.",
- "url": "http://127.0.0.1:8083/api/a2a/kagent/k8s-a2a-agent",
- "version": "1",
- "capabilities": {
- "streaming": false,
- "pushNotifications": false,
- "stateTransitionHistory": false
- },
- "defaultInputModes": [
- "text"
- ],
- "defaultOutputModes": [
- "text"
- ],
- "skills": [
+ "artifacts": [
{
- "id": "get-resources-skill",
- "name": "Get Resources",
- "description": "Get resources in the Kubernetes cluster",
- "examples": [
- "Get all resources in the Kubernetes cluster",
- "Get the pods in the default namespace",
- "Get the services in the istio-system namespace",
- "Get the deployments in the istio-system namespace",
- "Get the jobs in the istio-system namespace",
- "Get the cronjobs in the istio-system namespace",
- "Get the statefulsets in the istio-system namespace"
- ],
- "inputModes": [
- "text"
- ],
- "outputModes": [
- "text"
+ "artifactId": "c08e6186-6e6b-4b93-9042-bf9121863707",
+ "parts": [
+ {
+ "kind": "text",
+ "text": "There are 59 pods in your cluster."
+ }
]
}
]
+...
}
```
-## Use the A2A host CLI to invoke the agent
-
-We'll use the A2A host CLI to call the agent. This CLI part of the [A2A samples repository](https://github.com/a2aproject/a2a-samples/tree/main/samples/python/hosts/cli). Start by cloning the repository:
-
-```bash
-git clone https://github.com/a2aproject/a2a-samples.git
-```
-
-Then from the `a2a-samples/samples/python/hosts/cli` directory, run the CLI and point it to the kagent endpoint:
-
-```bash
-cd a2a-samples/samples/python/hosts/cli
-uv run . --agent http://127.0.0.1:8083/api/a2a/kagent/k8s-a2a-agent
-```
-
-The CLI will connect to the kagent, display the agent card and prompt you for input:
-
-```console
-======= Agent Card ========
-{"name":"my-a2a-agent","description":"An example A2A agent that knows how to use Kubernetes tools.","url":"http://127.0.0.1:8083/api/a2a/kagent/my-a2a-agent","version":"1","capabilities":{"streaming":false,"pushNotifications":false,"stateTransitionHistory":false},"defaultInputModes":["text"],"defaultOutputModes":["text"],"skills":[{"id":"kagent-k8s-agent","name":"Get Resources","description":"Get resources in the Kubernetes cluster","examples":["Get all resources in the Kubernetes cluster","Get the pods in the default namespace","Get the services in the istio-system namespace","Get the deployments in the istio-system namespace","Get the jobs in the istio-system namespace","Get the cronjobs in the istio-system namespace","Get the statefulsets in the istio-system namespace"],"inputModes":["text"],"outputModes":["text"]}]}
-========= starting a new task ========
-
-What do you want to send to the agent? (:q or quit to exit):
-```
-
-Let's send the task "Get the pods in the kagent namespace" to the agent. You'll be also prompted to optionally attach a file to the request, but just hit enter to skip this step. The request will be sent to the agent and the response will be displayed in the CLI. Her'es the formated version of the response:
-
-```json
-{
- "jsonrpc": "2.0",
- "id": "0df6761ed3394b43a2dee2bd6572bc94",
- "result": {
- "id": "89bae00376e44ed094a2174e163da9f6",
- "sessionId": "d966626d06ab42b19bd3999e65333311",
- "status": {
- "state": "completed",
- "message": {
- "role": "agent",
- "parts": [
- {
- "type": "text",
- "text": "Processed result: There is one pod running in the \"kagent\" namespace:\n\n- Pod Name: kagent-748fb675c6-9ddsz\n- Status: Running\n- Ready Containers: 3 out of 3\n- Restarts: 0\n- Age: 31 minutes\n- Pod IP: 10.244.0.11\n- Node: kagent-control-plane\n\nLet me know if you need more details or want to perform any actions on this pod."
- }
- ]
- },
- "timestamp": "2025-05-06T22:27:31+00:00"
- },
- "artifacts": [
- {
- "name": "Task Result",
- "description": "The result of the task processing",
- "parts": [
- {
- "type": "text",
- "text": "There is one pod running in the \"kagent\" namespace:\n\n- Pod Name: kagent-748fb675c6-9ddsz\n- Status: Running\n- Ready Containers: 3 out of 3\n- Restarts: 0\n- Age: 31 minutes\n- Pod IP: 10.244.0.11\n- Node: kagent-control-plane\n\nLet me know if you need more details or want to perform any actions on this pod."
- }
- ],
- "index": 0,
- "lastChunk": true
- }
- ]
- }
-}
-```
-
-The `result` section contains the result of the task and the `artifacts` section contains the output of the task and it shows the pods running inside the kagent namespace.
+### A2A host CLI
+
+You can use the A2A host CLI to invoke the agent. This CLI is part of the [A2A samples repository](https://github.com/a2aproject/a2a-samples/tree/main/samples/python/hosts/cli).
+
+1. Clone the A2A samples repository.
+
+ ```bash
+ git clone https://github.com/a2aproject/a2a-samples.git
+ ```
+
+2. From the `a2a-samples/samples/python/hosts/cli` directory, point the CLI to the kagent endpoint.
+
+ ```bash
+ cd a2a-samples/samples/python/hosts/cli
+ uv run . --agent http://127.0.0.1:8083/api/a2a/kagent/k8s-a2a-agent
+ ```
+
+ Example output: The CLI connects to the kagent, displays the agent card and prompts you for input.
+
+ ```console
+ ======= Agent Card ========
+ {"name":"my-a2a-agent","description":"An example A2A agent that knows how to use Kubernetes tools.","url":"http://127.0.0.1:8083/api/a2a/kagent/my-a2a-agent","version":"1","capabilities":{"streaming":false,"pushNotifications":false,"stateTransitionHistory":false},"defaultInputModes":["text"],"defaultOutputModes":["text"],"skills":[{"id":"kagent-k8s-agent","name":"Get Resources","description":"Get resources in the Kubernetes cluster","examples":["Get all resources in the Kubernetes cluster","Get the pods in the default namespace","Get the services in the istio-system namespace","Get the deployments in the istio-system namespace","Get the jobs in the istio-system namespace","Get the cronjobs in the istio-system namespace","Get the statefulsets in the istio-system namespace"],"inputModes":["text"],"outputModes":["text"]}]}
+ ========= starting a new task ========
+
+ What do you want to send to the agent? (:q or quit to exit):
+ ```
+
+3. Send the task `"Get the pods in the kagent namespace"` to the agent. You'll be also prompted to optionally attach a file to the request, but just hit enter to skip this step.
+
+ Example output: The `result` section contains the result of the task and the `artifacts` section contains the output of the task and it shows the pods running inside the kagent namespace.
+
+ ```json
+ {
+ "jsonrpc": "2.0",
+ "id": "0df6761ed3394b43a2dee2bd6572bc94",
+ "result": {
+ "id": "89bae00376e44ed094a2174e163da9f6",
+ "sessionId": "d966626d06ab42b19bd3999e65333311",
+ "status": {
+ "state": "completed",
+ "message": {
+ "role": "agent",
+ "parts": [
+ {
+ "type": "text",
+ "text": "Processed result: There is one pod running in the \"kagent\" namespace:\n\n- Pod Name: kagent-748fb675c6-9ddsz\n- Status: Running\n- Ready Containers: 3 out of 3\n- Restarts: 0\n- Age: 31 minutes\n- Pod IP: 10.244.0.11\n- Node: kagent-control-plane\n\nLet me know if you need more details or want to perform any actions on this pod."
+ }
+ ]
+ },
+ "timestamp": "2025-05-06T22:27:31+00:00"
+ },
+ "artifacts": [
+ {
+ "name": "Task Result",
+ "description": "The result of the task processing",
+ "parts": [
+ {
+ "type": "text",
+ "text": "There is one pod running in the \"kagent\" namespace:\n\n- Pod Name: kagent-748fb675c6-9ddsz\n- Status: Running\n- Ready Containers: 3 out of 3\n- Restarts: 0\n- Age: 31 minutes\n- Pod IP: 10.244.0.11\n- Node: kagent-control-plane\n\nLet me know if you need more details or want to perform any actions on this pod."
+ }
+ ],
+ "index": 0,
+ "lastChunk": true
+ }
+ ]
+ }
+ }
+ ```
The agent has processed the request and returned the result.
diff --git a/src/app/docs/kagent/examples/discord-a2a/page.mdx b/src/app/docs/kagent/examples/discord-a2a/page.mdx
index 787ce9f4..adf570aa 100644
--- a/src/app/docs/kagent/examples/discord-a2a/page.mdx
+++ b/src/app/docs/kagent/examples/discord-a2a/page.mdx
@@ -15,7 +15,7 @@ export const metadata = {
# Integrating kagent with Discord
-Kagent enables you to create AI agents that run inside your Kubernetes cluster. They can access a variety of [built-in tools](/docs/kagent/concepts/tools), fetch data from your [memory](/docs/kagent/concepts/memory), and use other [external tools via MCP](/docs/kagent/examples/documentation).
+Kagent enables you to create AI agents that run inside your Kubernetes cluster. They can access a variety of [built-in tools](/docs/kagent/concepts/tools) and use other [external tools via MCP](/docs/kagent/examples/documentation).
This guide shows how to connect a Discord bot to one of your agents using the A2A protocol, enabling natural conversations and command execution inside Discord.
diff --git a/src/app/docs/kagent/examples/page.mdx b/src/app/docs/kagent/examples/page.mdx
index f7b97cd2..c59acf99 100644
--- a/src/app/docs/kagent/examples/page.mdx
+++ b/src/app/docs/kagent/examples/page.mdx
@@ -10,6 +10,18 @@ export const metadata = {
author: "kagent.dev"
};
-# Examples
+import QuickLink from '@/components/quick-link';
-This section provides concrete examples of how to use kagent to build various AI-powered applications and workflows.
\ No newline at end of file
+
+
+
Examples
+
Explore practical examples of using kagent to build AI-powered apps.
+
+
+
+
+
+
+
+
+
diff --git a/src/app/docs/kagent/examples/slack-a2a/page.mdx b/src/app/docs/kagent/examples/slack-a2a/page.mdx
index 4dc57130..02c21de7 100644
--- a/src/app/docs/kagent/examples/slack-a2a/page.mdx
+++ b/src/app/docs/kagent/examples/slack-a2a/page.mdx
@@ -151,36 +151,39 @@ Let's deploy it:
```shell
kubectl apply -f - < New Agent**. The **Create New Agent** form opens.
-Set the following description:
+2. For the **Agent Name**, enter `k8sagent`.
-```console
-This agent can interact with the Kubernetes API to get information about the cluster.
-```
+3. For the **Agent Namespace**, select the namespace that you installed kagent in, `kagent`.
-Together with tools, agent instructions are what agent uses to interact with the user. They play an important role in instructing and guiding the agent on how and when to use tools, how to interact with the user, and what to do in certain scenarios. Think of these instructions as if you'd be giving them to a colleague who's new to the job.
+4. Although optional, enter a description for the agent. The description can help you remember what the agent does and why you created it.
-Let's set the following instructions for the agent:
+ ```console
+ This agent can interact with the Kubernetes API to get information about the cluster.
+ ```
-```md
-You're a friendly and helpful agent that uses Kubernetes tools to answer users questions about the cluster.
+5. Fill out the **Agent Instructions**. Together with tools, agent instructions are what agent uses to interact with the user. They play an important role in instructing and guiding the agent on how and when to use tools, how to interact with the user, and what to do in certain scenarios. Think of these instructions as if you'd be giving them to a colleague who's new to the job.
-# Instructions
+ >Note that the way you structure your instructions is up to you. You can add more details, or simplify them as needed. It's important to make sure the instructions are clear and easy to follow.
-- If user question is unclear, ask for clarification before running any tools
-- Always be helpful and friendly
-- If you don't know how to answer the question DO NOT make things up
- respond with "Sorry, I don't know how to answer that" and ask the user to further clarify the question
+ ```md
+ You're a friendly and helpful agent that uses Kubernetes tools to answer users questions about the cluster.
+
+ # Instructions
+
+ - If user question is unclear, ask for clarification before running any tools
+ - Always be helpful and friendly
+ - If you don't know how to answer the question DO NOT make things up
+ respond with "Sorry, I don't know how to answer that" and ask the user to further clarify the question
+
+ # Response format
+ - ALWAYS format your response as Markdown
+ - Your response will include a summary of actions you took and an explanation of the result
+ ```
-# Response format
-- ALWAYS format your response as Markdown
-- Your response will include a summary of actions you took and an explanation of the result
-```
+6. For the **Model**, select the default `gpt-4.1-mini` default model.
->Note that the way you structure your instructions is up to you. You can add more details, or simplify them as needed. It's important to make sure the instructions are clear and easy to follow.
+
-We'll leave the default model (GPT-4o) selected and move to the next step.
+{/* TODO memory
+## Adding memory
-## Adding tools
+Memories are database instances with information that you want the agent to have access to when completing tasks.
-Tools are the other building block of the agent. They are the commands that the agent can run to interact with the environment. As LLMs don't have the ability to run commands, tools are the way to bridge the gap between the agent and the environment. Kagent provides a set of built-in tools that you can use to interact with Kubernetes, Istio, Prometheus and projects. You can also [build your own tools](/tools)!
+Before you can add memories to an agent, you must first create a memory instance. For now, let's skip memory. When you're ready, you can check out the [memory guide](/docs/kagent/concepts/memory).
-For this agent, we'll add the following tools two tools - GetResources and GetAvailableAPIResources. The first tool will enable the agent to run *kubectl get* command and retrieve resources running in the cluster. The second tool will enable the agent to get a list of available API resources in the cluster.
+ */}
-Click the Add Tools button and search for **GetResources** and **GetAvailableAPIResources** - click on them to select them and then click the Save Selection to add them to the agent.
+## Adding tools
-
+Tools are an essential building block of the agent. They are the commands that the agent can run to interact with the environment. As LLMs don't have the ability to run commands, tools are the way to bridge the gap between the agent and the environment. Kagent provides a set of built-in tools that you can use to interact with Kubernetes, Istio, Prometheus and projects. You can also [build your own tools](/tools)!
-Last thing to do is to click the Create Agent button to create the agent.
+1. Click **Add Tools & Agents**. The selection panel opens.
+2. In the search bar, enter `k8s` to filter the available tools.
+3. Scroll through the list and select some tools, such as the following:
-### Configuring tools
+ * `k8s_get_available_api_resources`: Let the agent list the available API resources in the cluster.
+ * `k8s_get_resources`: Let the agent list the resources running in the cluster.
-Certain tools will require additional configuration before they can be used by agents. To configure the individual tools, click the settings icon in the list of tools to open the configuration dialog.
+4. Click **Save Selection** to add the tools to the agent.
-
+ 
## Testing the agent
-Once the agent is created, you'll be automatically redirected to the chat interface. You can ask the agent questions like "What pods are running in the cluster?" or "What are the available API resources?" and the agent will respond with the information.
+Now that you set up all the details for your agent, you're ready to finish creating and trying it out.
+
+1. Click **Create Agent** to create the agent.
+
+2. From the kagent UI landing page, find your `kagent/k8sagent` agent. You might have to refresh the page.
-Let's try asking the agent for the available API resources "Which API resources are available in my cluster?"
+ 
-The agent will call the `GetAvailableAPIResources` tool and then synthesize a response based on the result of that tool call.
+3. Click your agent, then enter a message such as "What API resources are running in my cluster?", and click **Send**. The agent uses the available tools as shown in the to help answer the question.
-
+ 
## Next Steps
diff --git a/src/app/docs/kagent/getting-started/first-mcp-tool/page.mdx b/src/app/docs/kagent/getting-started/first-mcp-tool/page.mdx
index 77811bfe..bf7ee992 100644
--- a/src/app/docs/kagent/getting-started/first-mcp-tool/page.mdx
+++ b/src/app/docs/kagent/getting-started/first-mcp-tool/page.mdx
@@ -19,192 +19,221 @@ In this guide, you'll learn how to add an MCP tool to your first AI agent using
## Prerequisites
-Before you begin make sure you have a Kubernetes cluster with kagent installed. If you haven't done this yet, check out the [installation guide](/docs/kagent/introduction/installation) or the [quickstart guide](/docs/kagent/getting-started/quickstart).
+1. Install kagent in a Kubernetes cluster. If you haven't done this yet, check out the [installation guide](/docs/kagent/introduction/installation) or the [quickstart guide](/docs/kagent/getting-started/quickstart).
-We'll be working with the kagent custom resources, so make sure you have them present on your cluster:
+2. Make sure that you have the kagent custom resources in your cluster.
-```shell
-kubectl get crd | grep kagent.dev
-```
-
-## Creating the agent
-
-Similar to the [first agent](/docs/kagent/getting-started/first-agent) guide, we will first create a simple agent that can interact with the cluster. This time we will use the `Agent` resource to create the agent.
-
-```shell
-kubectl apply -f - <Note that the way you structure your instructions is up to you. You can add more details, or simplify them as needed. It's important to make sure the instructions are clear and easy to follow.
-
-We'll leave the default model (GPT-4o) selected and move to the next step.
-
-## Adding tools
+ ```shell
+ kubectl get crd | grep kagent.dev
+ ```
-Tools are the other building block of the agent. They are the commands that the agent can run to interact with the environment. As LLMs don't have the ability to run commands, tools are the way to bridge the gap between the agent and the environment. Kagent provides a set of built-in tools that you can use to interact with Kubernetes, Istio, Prometheus and projects. You can also [build your own tools](/tools)!
+## Creating an agent
-In our Agent resource, we added two tools:
-- `GetResources`, which will enable the agent to run *kubectl get* command and retrieve resources running in the cluster.
-- `GetAvailableAPIResources`, which will enable the agent to get a list of available API resources in the cluster.
+To create an agent, follow the [Your First Agent guide](/docs/kagent/getting-started/first-agent).
-### Test out the agent
-
-Let's test out the agent by asking it a question. First we need to open the kagent dashboard and select the agent we just created. We can either use the `kagent` CLI tool to open the dashboard or port-forward manually:
+Take a look at the Agent custom resource for your first agent, such as with the following command.
```shell
-kubectl -n kagent port-forward svc/kagent 8001:80
+kubectl get agent my-first-k8s-agent -n kagent -o yaml
```
-
-
-In the chat interface, type "What pods are running in the cluster?" and press enter. The agent should respond with a list of pods running in the cluster and a call using the `GetResources` tool.
-
-
+Example output: Pay attention to the following details:
-### Configuring MCP tools
+* The `type` field is set to `Inline`. This means that the agent is using an inline model configuration and system message, as opposed to `BYO` where you can bring your own agent configuration separately.
+* The `inline` field contains the model configuration and system message.
+* The `systemMessage` field contains the system message that the agent will use. Note that the way you structure your instructions is up to you. You can add more details, or simplify them as needed. It's important to make sure the instructions are clear and easy to follow.
+* The `tools` field contains the tools that the agent can run to interact with the environment. The tools refer to a RemoteMCPServer, because these tools are built in to kagent. However, you can also create your own MCPServer or regular Kubernetes Service and designate the Service as for MCP use.
+* The `status` shows that the agent is accepted and ready.
-Let's create an agent that uses the MCP tools to retrieve information from a website using the Kagent resources. For this example, we will use a [simple MCP example server](https://github.com/peterj/mcp-website-fetcher/pkgs/container/mcp-website-fetcher) that only has one tool - the fetch tool. The fetch tool will take a URL as input and return the contents of the page.
-
-First let's apply a simple MCP server that will run in our cluster:
-```shell
-kubectl apply -f - <Note that MCP servers can implement multiple tools and as an agent developer you can decide which tools to use.
+Now let's try our agent out with the fetch tool.
-## Testing the agent with the MCP tool
+1. Open the kagent dashboard.
+
+ ```shell
+ kagent dashboard
+ ```
-Now let's try our agent out with the new integration. Open the kagent dashboard and select the agent we just created. You should see a new tool appear in the tool list.
+2. Select the **simple-fetch-agent** that you just created. Under **Agent Details**, you see the **fetch** tool.
-Now let's ask our agent a question. Type "Show me the contents of the https://en.wikipedia.org/wiki/Service_mesh website?" and press enter. The agent should respond with the contents of the website.
+3. In the chat box, enter `"Show me the contents of the https://en.wikipedia.org/wiki/Service_mesh website?"` and click **Send**. The agent responds with the contents of the website.

diff --git a/src/app/docs/kagent/getting-started/page.mdx b/src/app/docs/kagent/getting-started/page.mdx
index 844e378d..eaa8d382 100644
--- a/src/app/docs/kagent/getting-started/page.mdx
+++ b/src/app/docs/kagent/getting-started/page.mdx
@@ -10,6 +10,19 @@ export const metadata = {
author: "kagent.dev"
};
-# Getting Started
+import QuickLink from '@/components/quick-link';
-This section will guide you through the initial steps of using kagent.
\ No newline at end of file
+
+
+
Getting Started
+
Guides to help you get started with kagent, from quick setup to your first agent and tool.
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/app/docs/kagent/getting-started/quickstart/page.mdx b/src/app/docs/kagent/getting-started/quickstart/page.mdx
index 28e5a4ba..f8668b3d 100644
--- a/src/app/docs/kagent/getting-started/quickstart/page.mdx
+++ b/src/app/docs/kagent/getting-started/quickstart/page.mdx
@@ -39,127 +39,146 @@ export OPENAI_API_KEY="your-api-key-here"
curl https://raw.githubusercontent.com/kagent-dev/kagent/refs/heads/main/scripts/get-kagent | bash
```
-3. Install kagent to the cluster using the CLI. First run the CLI:
+3. Install the kmcp CRDs so that you can create MCP servers.
-```bash
-kagent install
-```
+ ```sh
+ helm install kmcp-crds oci://ghcr.io/kagent-dev/kmcp/helm/kmcp-crds \
+ --namespace kmcp-system \
+ --create-namespace
+ ```
-```console
-kagent installed successfully
-```
+4. Install kagent to the cluster by using the CLI.
-## Accessing the kagent dashboard (UI)
+ ```bash
+ kagent install
+ ```
-1. To open the kagent dashboard, run the dashboard command from the CLI
-
-```bash
-kagent dashboard
-```
-
-```console
-kagent dashboard is available at http://localhost:8082
-Press Enter to stop the port-forward...
-```
-
-The CLI will set up the port-forward to the service running inside the cluster and open the dashboard.
-
-
-
-## Running Your First AI Agent
+ ```console
+ kagent installed successfully
+ ```
-Once you're in the kagent UI, you can start interacting with the pre-configured sample agents. You can click on the agent card to view the agent details and start a conversation.
-
-
+## Accessing the kagent dashboard (UI)
-## Using the CLI
+1. To open the kagent dashboard, run the dashboard command from the CLI. The CLI sets up the port-forward to the UI service running inside the cluster and opens the dashboard.
-You can run *kagent* to start the REPL environment and then use commands to interact with kagent:
-
-```shell
-kagent >> help
-
-Commands:
- clear clear the screen
- dashboard Open the kagent dashboard.
- exit exit the program
- get get kagent resources.
- help display help
- install Install kagent.
- run Run a kagent agent
- uninstall Uninstall kagent.
- version Print the kagent version.
-```
+ ```bash
+ kagent dashboard
+ ```
-Let's start by listing the current agents:
-
-```shell
-kagent >> get agents
-+---+---------------------+----+----------------------------+
-| # | NAME | ID | CREATED |
-+---+---------------------+----+----------------------------+
-| 0 | helm-agent | 2 | 2025-03-13T19:08:14.527935 |
-| 1 | observability-agent | 3 | 2025-03-13T19:08:14.348957 |
-| 2 | istio-agent | 1 | 2025-03-13T19:08:13.794848 |
-+---+---------------------+----+----------------------------+
-```
+ ```console
+ kagent dashboard is available at http://localhost:8082
+ Press Enter to stop the port-forward...
+ ```
-To start a new agent, run the `run chat` command:
+2. Click **Let's Get Started** in the welcome wizard.
-```shell
-kagent >> run chat [agent-name] [session-name] [initial-task]
-```
-If you don't provide any flags, it will prompt you for the values:
+ 
-```shell
-kagent >> run chat
+3. Walk through the wizard screen by screen to set up your first agent. At any time, you can exist out of the wizard by clicking **Skip wizard**.
-Select an agent:
- observability-agent
- istio-agent
- ❯ helm-agent
+ * **Step 1: Configure AI Model**: Choose an existing model such as `gpt-4.1-mini`.
+ * **Step 2: Set up the AI Agent**: Review the default details for a basic Kubernetes agent.
+ * **Step 3: Select Tools**: Review the preselected tools for your first agent.
+ * **Step 4: Review Agent Configuration**: Review the details of your selections, then click **Create kagent/my-first-k8s-agent & Finish**.
-Select a session:
- ❯ [New Session]
-Enter a session name: test
-Enter a task: What helm chart are installed in my cluster?
-```
+ 
-Once a task has been entered, the agent will start running and you'll see the conversation in the CLI:
+Good job! You created your first agent. You can share your success, or click **Finish & Go to Agent**.
-```shell
-Event Type: ToolCall(s)
-Source: helm_agent
-+---+--------------------+-----------------------------------------+
-| # | NAME | ARGUMENTS |
-+---+--------------------+-----------------------------------------+
-| 0 | helm_list_releases | {"all_namespaces":true,"deployed":true} |
-+---+--------------------+-----------------------------------------+
-----------------------------------
+## Running Your First AI Agent
-Event Type: TextMessage
-Source: helm_agent
+Once you're in the kagent UI, you can start interacting with the pre-configured sample agents. You can click on the agent card to view the agent details and start a conversation.
-I found the following Helm release deployed across all namespaces:
+1. From the kagent UI landing page, find your `kagent/my-first-k8s-agent` agent. You might have to refresh the page.
-- **Release Name:** kagent
- - **Namespace:** kagent
- - **Revision:** 11
- - **Updated:** 2025-03-13 19:18:49 UTC
- - **Status:** Deployed
- - **Chart:** kagent-v0.0.18-4-g4926e59-dirty
+ 
-If you need more details about any specific release, let me know!
-----------------------------------
+2. Click your agent, then enter a message such as "What API resources are running in my cluster?", and click **Send**. The agent uses the available tools as shown in the to help answer the question.
-Usage: Prompt Tokens: 6573, Completion Tokens: 229
-helm-agent--test>
-```
+ 
-As you can see above, the agent found the `kagent` release. If anything else is running in your cluster, it will probably find that too.
+3. Click around to explore the UI some more.
+
+ * The menu shows a history of your chats as well as the ability to start a **New Chat**.
+ * The **Agent Details** panel shows the tools that the agent uses to respond to your messages.
+ * The chat interface includes **Arguments** and **Results** that you can expand to see more details about how your question was answered. For example, the **Results** show the output of the `kubectl` terminal commands that the agent ran to list the API resources in your cluster.
+
+ 
-Now keep chatting with the agent to see what other things it can do :)
+## Using the CLI
+Interact with kagent in your terminal.
+
+1. Review the available commands.
+
+ ```shell
+ kagent help
+
+ Available Commands:
+ bug-report Generate a bug report
+ completion Generate the autocompletion script for the specified shell
+ dashboard Open the kagent dashboard
+ get Get a kagent resource
+ help Help about any command
+ install Install kagent
+ invoke Invoke a kagent agent
+ uninstall Uninstall kagent
+ version Print the kagent version
+ ```
+
+2. List the current agents.
+
+ ```shell
+ kagent get agents
+ +---+---------------------+----+----------------------------+
+ | # | NAME | ID | CREATED |
+ +---+---------------------+----+----------------------------+
+ | 0 | helm-agent | 2 | 2025-03-13T19:08:14.527935 |
+ | 1 | observability-agent | 3 | 2025-03-13T19:08:14.348957 |
+ | 2 | istio-agent | 1 | 2025-03-13T19:08:13.794848 |
+ +---+---------------------+----+----------------------------+
+ ```
+
+3. Interact with an agent with the `invoke` command. The agent is called and a conversation starts.
+
+ ```shell
+ kagent invoke -t "What Helm charts are in my cluster?" --agent helm-agent
+ ```
+
+ Example output:
+
+ ```console
+ Event Type: ToolCall(s)
+ Source: helm_agent
+ +---+--------------------+-----------------------------------------+
+ | # | NAME | ARGUMENTS |
+ +---+--------------------+-----------------------------------------+
+ | 0 | helm_list_releases | {"all_namespaces":true,"deployed":true} |
+ +---+--------------------+-----------------------------------------+
+ ----------------------------------
+
+ Event Type: TextMessage
+ Source: helm_agent
+
+ I found the following Helm release deployed across all namespaces:
+
+ - **Release Name:** kagent
+ - **Namespace:** kagent
+ - **Revision:** 11
+ - **Updated:** 2025-03-13 19:18:49 UTC
+ - **Status:** Deployed
+ - **Chart:** kagent-v0.0.18-4-g4926e59-dirty
+
+ If you need more details about any specific release, let me know!
+ ----------------------------------
+
+ Usage: Prompt Tokens: 6573, Completion Tokens: 229
+ helm-agent--test>
+ ```
+
+As you can see from the example, the agent found the `kagent` Helm chart release. If anything else is running in your cluster, it will probably find that too.
+
+Now, keep chatting with the agent to see what other things it can do :)
## Next Steps
diff --git a/src/app/docs/kagent/getting-started/tracing/page.mdx b/src/app/docs/kagent/getting-started/tracing/page.mdx
index 25dbd3fd..57a63298 100644
--- a/src/app/docs/kagent/getting-started/tracing/page.mdx
+++ b/src/app/docs/kagent/getting-started/tracing/page.mdx
@@ -10,23 +10,30 @@ export const metadata = {
author: "kagent.dev"
};
-# Prerequisites
+## Prerequisites
-- [kind](https://kind.sigs.k8s.io/docs/user/quick-start/) for creating and running a local Kubernetes cluster
-- [Helm](https://helm.sh/docs/intro/install/) - for installing the kagent chart
-- [kubectl](https://kubernetes.io/docs/tasks/tools/) - for interacting with your cluster
+This guide walks you through all the steps you need to get started with tracing your kagent agents, including a basic installation. However, you might want to try out the other getting started guides first to get a better understanding of how kagent works.
-This guide will walk you through all the steps you need to get started with tracing your kagent agents. However, we recommend starting with the other getting-started guides first to get a better understanding of how kagent works.
+- [kind](https://kind.sigs.k8s.io/docs/user/quick-start/) for creating and running a local Kubernetes cluster.
+- [Helm](https://helm.sh/docs/intro/install/) for installing the kagent chart.
+- [kubectl](https://kubernetes.io/docs/tasks/tools/) for interacting with your cluster.
+- kagent CLI for interacting with kagent, such as to launch the dashboard.
-To run the AI agents you'll also need an [OpenAI](https://openai.com) API key. You can [get one here](https://platform.openai.com/account/api-keys).
+ ```bash
+ # Download/run the install script
+ curl https://raw.githubusercontent.com/kagent-dev/kagent/refs/heads/main/scripts/get-kagent | bash
+ ```
+
+To run the AI agents you also need an [OpenAI](https://openai.com) API key. You can [get one here](https://platform.openai.com/account/api-keys).
## Installing Jaeger
In order to demonstrate tracing, we'll first need to install Jaeger. We will use the Jaeger all in one mode to demonstrate the tracing capabilities without needing to install any other components.
-Firstly create a file called `jaeger.yaml` with the following content:
+Create the `jaeger.yaml` file using the following command:
```yaml
+cat << 'EOF' > jaeger.yaml
provisionDataStore:
cassandra: false
allInOne:
@@ -39,6 +46,7 @@ collector:
enabled: false
query:
enabled: false
+EOF
```
Then install Jaeger using the following command:
@@ -55,92 +63,102 @@ helm upgrade --install jaeger jaegertracing/jaeger \
## Installing kagent
+The following steps include commands to install or upgrade the kagent Helm release.
+
1. Set the OpenAI API key as an environment variable:
-```bash
-export OPENAI_API_KEY="your-api-key-here"
-```
+ ```bash
+ export OPENAI_API_KEY="your-api-key-here"
+ ```
-2. Install the Helm chart with CRDs:
+2. If you did not already, install the kagent CRDs.
-```bash
-helm install kagent-crds oci://ghcr.io/kagent-dev/kagent/helm/kagent-crds \
- --namespace kagent \
- --create-namespace
-```
-3. Create a file called `kagent-tracing.yaml` with the following content:
+ ```bash
+ helm upgrade --install kagent-crds oci://ghcr.io/kagent-dev/kagent/helm/kagent-crds \
+ --namespace kagent \
+ --create-namespace
+ ```
-```yaml
-otel:
- tracing:
- enabled: true
- exporter:
- otlp:
- endpoint: http://jaeger-collector.jaeger.svc.cluster.local:4317
-```
+3. If you already installed kagent, get your current Helm release values.
-4. Install the kagent Helm chart:
+ ```shell
+ helm get values kagent -n kagent > values.yaml
+ ```
-```bash
-helm install kagent oci://ghcr.io/kagent-dev/kagent/helm/kagent \
- --namespace kagent \
- --set providers.openAI.apiKey=$OPENAI_API_KEY \
- --values kagent-tracing.yaml
-```
+3. Create or update your values file to include the following settings to enable tracing.
+
+ ```yaml
+ otel:
+ tracing:
+ enabled: true
+ exporter:
+ otlp:
+ endpoint: http://jaeger-collector.jaeger.svc.cluster.local:4317
+ ```
+
+4. Install or upgrade the kagent Helm chart with the tracing details.
+
+ ```bash
+ helm upgrade -i kagent oci://ghcr.io/kagent-dev/kagent/helm/kagent \
+ --namespace kagent \
+ --set providers.openAI.apiKey=$OPENAI_API_KEY \
+ --values values.yaml
+ ```
## Tracing your first agent
-Now that we have Jaeger installed and kagent configured to use it, we can start tracing our first agent.
+Now that you installed kagent with Jaeger, learn how to trace requests to an agent.
-1. Download the kagent CLI:
+### Generate tracing data
-```bash
-# Download/run the install script
-curl https://raw.githubusercontent.com/kagent-dev/kagent/refs/heads/main/scripts/get-kagent | bash
-```
+To generate tracing data, you can chat with a pre-configured agent such as `k8s-agent`. For more information about agents, see the [Your First Agent](/docs/kagent/getting-started/first-agent) guide.
-## Accessing the kagent dashboard (UI)
+1. Launch the kagent dashboard.
-2. To open the kagent dashboard, run the dashboard command from the CLI
+ ```bash
+ kagent dashboard
+ ```
-```bash
-kagent dashboard
-```
+ Example output:
-```console
-kagent dashboard is available at http://localhost:8082
-Press Enter to stop the port-forward...
-```
+ ```console
+ kagent dashboard is available at http://localhost:8082
+ Press Enter to stop the port-forward...
+ ```
-The CLI will set up the port-forward to the service running inside the cluster and open the dashboard.
+ 
-
+2. Click the pre-configured `k8s-agent` agent.
-## Running the k8s-agent
+3. In the conversation box, enter a query such as "What pods are running in my cluster?".
-Once you're in the kagent UI, you can start interacting with the pre-configured sample agents. You can click on the agent card to view the agent details and start a conversation. For the purpose of this guide, we'll use the `k8s-agent` agent. Specifically we'll use the `k8s-agent` agent to get the list of pods in the cluster.
+ 
-For testing purposes, we'll use the `k8s-agent` agent to get the list of pods in the cluster.
+### Review tracing data in Jaeger
-
+Review the tracing data in Jaeger for the agent queries that you just sent.
-Once that query is complete, we can go take a look at the data in Jaeger.
+1. In your terminal, enable port-forwarding for the Jaeger query service.
-```bash
-kubectl port-forward svc/jaeger-query -n jaeger 16686:16686
-```
+ ```bash
+ kubectl port-forward svc/jaeger-query -n jaeger 16686:16686
+ ```
+
+2. In your browser, open the Jaeger UI: [http://localhost:16686](http://localhost:16686).
+
+3. From the Jaeger **Search** menu, in the **Service** dropdown, select the `kagent` service.
-Once the port-forward is set up, you can open the Jaeger UI in your browser at [http://localhost:16686](http://localhost:16686).
+4. In the **Operation** dropdown, select `agent_run [k8s-agent]` to filter for traces specific to the agent.
-From the Jaeger UI, select the `kagent` service on the top-left and then hit "search" to see the traces for the `k8s-agent` agent.
+5. Click **Find Traces**.
-Specifically the result we're looking for should resemble the following:
+6. Review the traces for the `kagent` service.
-
+ 
-Once you've found the trace, you can click on it to see the details.
+7. Click on a trace to see more details.
-
+ 
That's it! You've now traced your first agent.
diff --git a/src/app/docs/kagent/introduction/installation/page.mdx b/src/app/docs/kagent/introduction/installation/page.mdx
index a58a9133..a539a1c4 100644
--- a/src/app/docs/kagent/introduction/installation/page.mdx
+++ b/src/app/docs/kagent/introduction/installation/page.mdx
@@ -20,53 +20,69 @@ This guide covers ways to install and configure kagent in your Kubernetes enviro
1. Set the OpenAI API key as an environment variable:
-```bash
-export OPENAI_API_KEY="your-api-key-here"
-```
+ ```bash
+ export OPENAI_API_KEY="your-api-key-here"
+ ```
2. Download the kagent CLI:
-```bash
-# Download/run the install script
-curl https://raw.githubusercontent.com/kagent-dev/kagent/refs/heads/main/scripts/get-kagent | bash
-```
+ ```bash
+ # Download/run the install script
+ curl https://raw.githubusercontent.com/kagent-dev/kagent/refs/heads/main/scripts/get-kagent | bash
+ ```
-3. Install kagent to the cluster using the CLI. First run the CLI:
+3. Install the kmcp CRDs so that you can create MCP servers.
-```bash
-kagent install
-```
+ ```sh
+ helm install kmcp-crds oci://ghcr.io/kagent-dev/kmcp/helm/kmcp-crds \
+ --namespace kmcp-system \
+ --create-namespace
+ ```
-```console
-kagent installed successfully
-```
+4. Install kagent to the cluster by using the CLI.
+
+ ```bash
+ kagent install
+ ```
+
+ ```console
+ kagent installed successfully
+ ```
### Using Helm
Another way to install kagent is using Helm.
-1. Install the Helm chart with CRDs:
+1. Install the kagent Helm chart with CRDs.
-```bash
-helm install kagent-crds oci://ghcr.io/kagent-dev/kagent/helm/kagent-crds \
- --namespace kagent \
- --create-namespace
-```
+ ```bash
+ helm install kagent-crds oci://ghcr.io/kagent-dev/ kagent/helm/kagent-crds \
+ --namespace kagent \
+ --create-namespace
+ ```
-2. Set the `OPENAI_API_KEY` environment variable:
+2. Install the kmcp CRDs so that you can create MCP servers.
-```bash
-export OPENAI_API_KEY="your-api-key-here"
-```
+ ```sh
+ helm install kmcp-crds oci://ghcr.io/kagent-dev/kmcp/helm/kmcp-crds \
+ --namespace kmcp-system \
+ --create-namespace
+ ```
-3. Install the kagent Helm chart:
+3. Set the `OPENAI_API_KEY` environment variable:
-```bash
-helm install kagent oci://ghcr.io/kagent-dev/kagent/helm/kagent \
- --namespace kagent \
- --set providers.openAI.apiKey=$OPENAI_API_KEY
-```
+ ```bash
+ export OPENAI_API_KEY="your-api-key-here"
+ ```
+
+4. Install the kagent Helm chart:
+
+ ```bash
+ helm install kagent oci://ghcr.io/kagent-dev/kagent/helm/kagent \
+ --namespace kagent \
+ --set providers.openAI.apiKey=$OPENAI_API_KEY
+ ```
## Uninstallation
diff --git a/src/app/docs/kagent/introduction/page.mdx b/src/app/docs/kagent/introduction/page.mdx
index 7449c987..beaab01e 100644
--- a/src/app/docs/kagent/introduction/page.mdx
+++ b/src/app/docs/kagent/introduction/page.mdx
@@ -10,13 +10,18 @@ export const metadata = {
author: "kagent.dev"
};
-# Introduction
+import QuickLink from '@/components/quick-link';
-This section provides an overview of kagent, including installation instructions, our feature roadmap, and guidelines for contributing to the project.
+
+
+
Introduction
+
Welcome to kagent! Start here to understand what kagent is, how to install it, and how to contribute.
+
-Explore the following pages to get started:
-
-- **[What is kagent?](/docs/kagent/introduction/what-is-kagent)**: Learn about the core concepts and capabilities of kagent.
-- **[Installation](/docs/kagent/introduction/installation)**: Follow our guide to set up kagent.
-- **[Feature Roadmap](https://github.com/kagent-dev/kagent/blob/main/README.md#roadmap)**: See what we're planning for the future.
-- **[Contributing](https://github.com/kagent-dev/kagent/blob/main/CONTRIBUTION.md)**: Find out how you can help improve kagent.
\ No newline at end of file
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/app/docs/kagent/resources/page.mdx b/src/app/docs/kagent/resources/page.mdx
index df5e6633..a005fe86 100644
--- a/src/app/docs/kagent/resources/page.mdx
+++ b/src/app/docs/kagent/resources/page.mdx
@@ -10,15 +10,20 @@ export const metadata = {
author: "kagent.dev"
};
-# Resources
+import QuickLink from '@/components/quick-link';
-This section contains additional resources to help you with kagent, including troubleshooting guides, frequently asked questions, and ways to connect with the community.
+
+
+
Resources
+
Find helpful resources, troubleshooting tips, and FAQs for kagent. Access guides, community links, and more.
+
-## Helpful Links
-
-- [Troubleshooting Guide](/docs/kagent/resources/troubleshooting)
-- [Frequently Asked Questions](/docs/kagent/resources/faq)
-- [Quick Start Guide](/docs/kagent/getting-started/quickstart)
-- [Official GitHub Repository](https://github.com/kagent-dev/kagent)
-- [Contribution Guide](https://github.com/kagent-dev/kagent/blob/main/CONTRIBUTION.md)
-- [Join our Discord Community](https://discord.gg/Fu3k65f2k3)
\ No newline at end of file
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/app/docs/kagent/resources/release-notes/page.mdx b/src/app/docs/kagent/resources/release-notes/page.mdx
index 878a2026..11b4cefa 100644
--- a/src/app/docs/kagent/resources/release-notes/page.mdx
+++ b/src/app/docs/kagent/resources/release-notes/page.mdx
@@ -20,11 +20,17 @@ The kagent documentation shows information only for the latest release. If you r
Review the main changes from kagent version 0.5 to v0.6, then continue reading for more detailed information.
+* The `apiVersion` field in the kagent CRDs is now `kagent.dev/v1alpha2`.
* A new Helm chart for kmcp CRDs is available.
* API string references to resources in other namespaces in the format `namespace/name` now fail. Instead, the APIs have a separate field for you to specify the namespace of the resource.
* The Tools API moves or eliminates some APIs entirely in favor of new kmcp APIs.
* The Agents APIs now require a top-level `type` field to support the new BYO agent functionality.
-* The ModelConfig APIs rename the secret name field from `apiKeySecretRef` to `apiKeySecret`.
+* The ModelConfig APIs rename the secret name field from `apiKeySecret` to `apiKeySecret`.
+* Memory APIs are not supported in ADK.
+
+## Upgraded API version
+
+The `apiVersion` field in the kagent CRDs is now `kagent.dev/v1alpha2`.
## New! Helm chart for kmcp CRDs
@@ -57,9 +63,11 @@ Previously, the kagent installation included only one CRD Helm chart. Now, you i
```
-## General API changes
+## General changes
+
+**`namespace/name` references**: API string references to resources in other namespaces in the format `namespace/name` now fail. Instead, the APIs have a separate field for you to specify the namespace of the resource.
-API string references to resources in other namespaces in the format `namespace/name` now fail. Instead, the APIs have a separate field for you to specify the namespace of the resource.
+**Local development `buildx` access**: The `make helm-install` command now creates a local Docker registry to push development images to. As part of the build process, you might need to allow the buildx builder to access your host network. For more information, see the [developer docs in the kagent repo](https://github.com/kagent-dev/kagent/blob/main/DEVELOPMENT.md#troubleshooting).
## Tools APIs
@@ -83,7 +91,7 @@ Flip through the following tabs to understand the API differences between the ol
* The `stdio` config section includes the Grafana deployment details.
* The Grafana details, including the API key, are loaded as environment settings directly in the ToolServer.
```yaml
- apiVersion: kagent.dev/v1alpha1
+ apiVersion: kagent.dev/v1alpha2
kind: ToolServer
metadata:
name: mcp-grafana
@@ -122,7 +130,7 @@ Flip through the following tabs to understand the API differences between the ol
data:
GRAFANA_API_KEY: my-base-64-ikey
---
- apiVersion: kagent.dev/v1alpha1
+ apiVersion: kagent.dev/v1alpha2
kind: MCPServer
metadata:
name: grafana
@@ -157,7 +165,7 @@ ToolServer resources that used `type: streamableHttp` are now configured as Remo
Old ToolServer API:
```yaml
- apiVersion: kagent.dev/v1alpha1
+ apiVersion: kagent.dev/v1alpha2
kind: ToolServer
metadata:
name: kagent-tool-server
@@ -211,7 +219,7 @@ spec:
protocol: TCP
targetPort: http
---
-apiVersion: kagent.dev/v1alpha1
+apiVersion: kagent.dev/v1alpha2
kind: ToolServer
metadata:
name: kagent-querydoc
@@ -355,8 +363,8 @@ This change supports the new type for BYO agents.
namespace: kagent
spec:
description: An Kubernetes Expert AI Agent specializing in cluster operations, troubleshooting, and maintenance.
- type: Inline
- inline:
+ type: Declarative
+ declarative:
systemMessage: |
# Kubernetes AI Agent System Prompt
@@ -365,7 +373,7 @@ This change supports the new type for BYO agents.
```
**Key Changes:**
- * Added `type: Inline` field to specify agent type
+ * Added `type: Declarative` field to specify agent type
* Agent configuration now under `inline` section
* Supports new BYO deployment model
@@ -397,4 +405,8 @@ spec:
## ModelConfig API
-The secret name field is renamed from `apiKeySecretRef` to `apiKeySecret`.
+The secret name field is renamed from `apiKeySecret` to `apiKeySecret`.
+
+## Memory API
+
+The Memory API is not supported in ADK. The [agent development kit](https://google.github.io/adk-docs/) is required to bring your own agents. As such, the Memory docs are removed.
diff --git a/src/app/docs/kagent/supported-providers/anthropic/page.mdx b/src/app/docs/kagent/supported-providers/anthropic/page.mdx
index ba73dbcd..29176e0a 100644
--- a/src/app/docs/kagent/supported-providers/anthropic/page.mdx
+++ b/src/app/docs/kagent/supported-providers/anthropic/page.mdx
@@ -23,13 +23,13 @@ kubectl create secret generic kagent-anthropic -n kagent --from-literal ANTHROPI
2. Create a ModelConfig resource that references the secret and key name, and specify the Anthropic model you want to use:
```yaml
-apiVersion: kagent.dev/v1alpha1
+apiVersion: kagent.dev/v1alpha2
kind: ModelConfig
metadata:
name: claude-model-config
namespace: kagent
spec:
- apiKeySecretRef: kagent-anthropic
+ apiKeySecret: kagent-anthropic
apiKeySecretKey: ANTHROPIC_API_KEY
model: claude-3-sonnet-20240229
provider: Anthropic
diff --git a/src/app/docs/kagent/supported-providers/azure-openai/page.mdx b/src/app/docs/kagent/supported-providers/azure-openai/page.mdx
index d1b2ef6c..03cd1a42 100644
--- a/src/app/docs/kagent/supported-providers/azure-openai/page.mdx
+++ b/src/app/docs/kagent/supported-providers/azure-openai/page.mdx
@@ -22,13 +22,13 @@ kubectl create secret generic kagent-azureopenai -n kagent --from-literal AZURE_
2. Create a ModelConfig resource that references the secret and key name, and specify the additional information that's required for the Azure OpenAI - that's the deployment name, version and the Azure AD token. You can get these values from Azure.
```yaml
-apiVersion: kagent.dev/v1alpha1
+apiVersion: kagent.dev/v1alpha2
kind: ModelConfig
metadata:
- name: azureopenai-model-config
+ name: azuredefault-model-config
namespace: kagent
spec:
- apiKeySecretRef: kagent-azureopenai
+ apiKeySecret: kagent-azureopenai
apiKeySecretKey: AZURE_OPENAI_API_KEY
model: gpt-4o-mini
provider: AzureOpenAI
diff --git a/src/app/docs/kagent/supported-providers/custom-models/page.mdx b/src/app/docs/kagent/supported-providers/custom-models/page.mdx
index b129d48d..212d6607 100644
--- a/src/app/docs/kagent/supported-providers/custom-models/page.mdx
+++ b/src/app/docs/kagent/supported-providers/custom-models/page.mdx
@@ -102,13 +102,13 @@ kubectl create secret generic kagent-openai -n kagent --from-literal OPENAI_API_
2. Create a ModelConfig resource that references the secret and key name, and specify the model you want to use:
```yaml
-apiVersion: kagent.dev/v1alpha1
+apiVersion: kagent.dev/v1alpha2
kind: ModelConfig
metadata:
name: custom-openai-model-config
namespace: kagent
spec:
- apiKeySecretRef: kagent-openai
+ apiKeySecret: kagent-openai
apiKeySecretKey: OPENAI_API_KEY
model: # This should match the model name passed to the provider.
provider: OpenAI
@@ -124,7 +124,7 @@ spec:
multipleSystemMessages: false
```
-If you don't need an API key you can elide the `apiKeySecretRef` and `apiKeySecretKey` fields.
+If you don't need an API key you can elide the `apiKeySecret` and `apiKeySecretKey` fields.
3. Apply the above resource to the cluster.
diff --git a/src/app/docs/kagent/supported-providers/google-vertexai/page.mdx b/src/app/docs/kagent/supported-providers/google-vertexai/page.mdx
index b1d16a07..8fb06a4c 100644
--- a/src/app/docs/kagent/supported-providers/google-vertexai/page.mdx
+++ b/src/app/docs/kagent/supported-providers/google-vertexai/page.mdx
@@ -23,13 +23,13 @@ kubectl create secret generic kagent-google-creds -n kagent --from-file=./google
2. For Gemini models: create a ModelConfig resource using the `GeminiVertexAI` provider that references the secret and key name, and specify the Gemini model you want to use. Note the `projectID` and `location` are required:
```yaml
-apiVersion: kagent.dev/v1alpha1
+apiVersion: kagent.dev/v1alpha2
kind: ModelConfig
metadata:
name: gemini-model-config-vertexai
namespace: kagent
spec:
- apiKeySecretRef: kagent-google-creds
+ apiKeySecret: kagent-google-creds
apiKeySecretKey: google_creds.json
model: gemini-2.0-flash-lite
provider: GeminiVertexAI
@@ -42,13 +42,13 @@ spec:
3. For Anthropic models: create a ModelConfig resource using the `AnthropicVertexAI` provider that references the secret and key name, and specify the Anthropic model you want to use. Note the `projectID` and `location` are required:
```yaml
-apiVersion: kagent.dev/v1alpha1
+apiVersion: kagent.dev/v1alpha2
kind: ModelConfig
metadata:
name: anthropic-model-config-vertexai
namespace: kagent
spec:
- apiKeySecretRef: kagent-google-creds
+ apiKeySecret: kagent-google-creds
apiKeySecretKey: google_creds.json
model: claude-sonnet-4@20250514
provider: AnthropicVertexAI
diff --git a/src/app/docs/kagent/supported-providers/ollama/page.mdx b/src/app/docs/kagent/supported-providers/ollama/page.mdx
index d653fd6f..c0532f25 100644
--- a/src/app/docs/kagent/supported-providers/ollama/page.mdx
+++ b/src/app/docs/kagent/supported-providers/ollama/page.mdx
@@ -72,14 +72,14 @@ Once the pod has started, you can port-forward to the Ollama service and use `ol
Let's assume we've downloaded the `llama3` model, you can then use the following ModelConfig to configure the model:
```yaml
-apiVersion: kagent.dev/v1alpha1
+apiVersion: kagent.dev/v1alpha2
kind: ModelConfig
metadata:
name: llama3-model-config
namespace: kagent
spec:
apiKeySecretKey: OPENAI_API_KEY
- apiKeySecretRef: kagent-openai
+ apiKeySecret: kagent-openai
model: llama3
provider: Ollama
ollama:
diff --git a/src/app/docs/kagent/supported-providers/openai/page.mdx b/src/app/docs/kagent/supported-providers/openai/page.mdx
index aa4b0906..546a5358 100644
--- a/src/app/docs/kagent/supported-providers/openai/page.mdx
+++ b/src/app/docs/kagent/supported-providers/openai/page.mdx
@@ -22,13 +22,13 @@ kubectl create secret generic kagent-openai -n kagent --from-literal OPENAI_API_
2. Create a ModelConfig resource that references the secret and key name:
```yaml
-apiVersion: kagent.dev/v1alpha1
+apiVersion: kagent.dev/v1alpha2
kind: ModelConfig
metadata:
- name: openai-model-config
+ name: default-model-config
namespace: kagent
spec:
- apiKeySecretRef: kagent-openai
+ apiKeySecret: kagent-openai
apiKeySecretKey: OPENAI_API_KEY
model: gpt-4o-mini
provider: OpenAI
diff --git a/src/app/docs/kmcp/deploy/install-controller/page.mdx b/src/app/docs/kmcp/deploy/install-controller/page.mdx
index 48e4951b..5e9a0815 100644
--- a/src/app/docs/kmcp/deploy/install-controller/page.mdx
+++ b/src/app/docs/kmcp/deploy/install-controller/page.mdx
@@ -29,7 +29,15 @@ The kmcp controller manages the lifecycle of MCP servers that are defined in an
kind create cluster
```
-2. Install the following kmcp controller components in your cluster.
+2. Install the kmcp CRDs.
+
+ ```sh
+ helm install kmcp-crds oci://ghcr.io/kagent-dev/kmcp/helm/kmcp-crds \
+ --namespace kmcp-system \
+ --create-namespace
+ ```
+
+3. Install the following kmcp controller components in your cluster.
* The MCPServer Custom Resource Definition to define your MCP server.
* The ClusterRole and ClusterRoleBinding to control RBAC permissions for the kmcp controller.
* The kmcp controller deployment that automatically manages the lifecycle of MCPServer resources.
@@ -54,7 +62,7 @@ The kmcp controller manages the lifecycle of MCP servers that are defined in an
💡 View controller logs with: kubectl logs -l app.kubernetes.io/name=kmcp -n kmcp-system
```
-3. Verify that the kmcp controller manager is up and running.
+4. Verify that the kmcp controller manager is up and running.
```sh
kubectl get pods -n kmcp-system
```
@@ -65,7 +73,7 @@ The kmcp controller manages the lifecycle of MCP servers that are defined in an
kmcp-controller-manager-66c8764c66-8h5sl 1/1 Running 0 27h
```
-4. Optional: Look at the logs of the kmcp controller manager.
+5. Optional: Look at the logs of the kmcp controller manager.
```sh
kubectl logs -l app.kubernetes.io/name=kmcp -n kmcp-system
```
diff --git a/src/app/docs/kmcp/deploy/page.mdx b/src/app/docs/kmcp/deploy/page.mdx
index 3b43dc89..decde3c8 100644
--- a/src/app/docs/kmcp/deploy/page.mdx
+++ b/src/app/docs/kmcp/deploy/page.mdx
@@ -10,10 +10,16 @@ export const metadata = {
author: "kagent.dev"
};
-# Deploy to Kubernetes
+import QuickLink from '@/components/quick-link';
-Use the kmcp controller to manage the lifecycle of your MCP servers in a Kubernetes environment.
+
+
+
Deploy to Kubernetes
+
Use the kmcp controller to manage the lifecycle of your MCP servers in a Kubernetes environment.
+
-Explore the following guides to get started:
-* [Install the kmcp controller](/docs/kmcp/deploy/install-controller)
-* [Deploy MCP servers](/docs/kmcp/deploy/server)
+
+
+
+
+
diff --git a/src/app/docs/kmcp/deploy/server/page.mdx b/src/app/docs/kmcp/deploy/server/page.mdx
index a5b46754..09aa53c3 100644
--- a/src/app/docs/kmcp/deploy/server/page.mdx
+++ b/src/app/docs/kmcp/deploy/server/page.mdx
@@ -45,7 +45,7 @@ Use the kmcp controller to automatically spin up your MCP server in a Kubernetes
* FastMCP example
```yaml
kubectl apply -f- <
+
+
Develop MCP servers
+
Use kmcp to quickly create and initialize an MCP project on your local machine. kmcp automatically generates all the necessary files and dependencies so that you can get started with developing your MCP server and tools.
+
-Select one of the following MCP frameworks to get started:
-
-* [FastMCP Python](/docs/kmcp/develop/fastmcp-python)
-* [MCP Go](/docs/kmcp/develop/mcp-go)
+
+
+
+
+
diff --git a/src/app/docs/kmcp/quickstart/page.mdx b/src/app/docs/kmcp/quickstart/page.mdx
index 0452d084..49e8658f 100644
--- a/src/app/docs/kmcp/quickstart/page.mdx
+++ b/src/app/docs/kmcp/quickstart/page.mdx
@@ -86,7 +86,15 @@ With your first FastMCP Python server up and running, you can now deploy it to a
kind create cluster
```
-2. Install the following kmcp controller components in your cluster.
+2. Install the kmcp CRDs.
+
+ ```sh
+ helm install kmcp-crds oci://ghcr.io/kagent-dev/kmcp/helm/kmcp-crds \
+ --namespace kmcp-system \
+ --create-namespace
+ ```
+
+3. Install the following kmcp controller components in your cluster.
* The MCPServer Custom Resource Definition to define your MCP server.
* The ClusterRole and ClusterRoleBinding to control RBAC permissions for the kmcp controller.
* The kmcp controller deployment that automatically manages the lifecycle of MCPServer resources.
@@ -111,7 +119,7 @@ With your first FastMCP Python server up and running, you can now deploy it to a
💡 View controller logs with: kubectl logs -l app.kubernetes.io/name=kmcp -n kmcp-system
```
-3. Verify that the kmcp controller manager is up and running.
+4. Verify that the kmcp controller manager is up and running.
```sh
kubectl get pods -n kmcp-system
```
diff --git a/src/app/docs/kmcp/reference/page.mdx b/src/app/docs/kmcp/reference/page.mdx
index 66eac19e..191831d9 100644
--- a/src/app/docs/kmcp/reference/page.mdx
+++ b/src/app/docs/kmcp/reference/page.mdx
@@ -4,13 +4,21 @@ pageOrder: 100
description: ""
---
-# Reference
+import QuickLink from '@/components/quick-link';
-Review the KMCP commands:
-* [kmcp add-tool](/docs/kmcp/reference/kmcp-add-tool) to generate an MCP tool boilerplate that you can use as the base to create your own.
-* [kmcp build](/docs/kmcp/reference/kmcp-build) to build a Docker image for your MCP server.
-* [kmcp deploy](/docs/kmcp/reference/kmcp-deploy) to deploy your MCP server to a Kubernetes cluster.
-* [kmcp init](/docs/kmcp/reference/kmcp-init) to create a scaffold for your MCP server project.
-* [kmcp install](/docs/kmcp/reference/kmcp-install) to install the KMCP controller manager and all its dependencies.
-* [kmcp run](/docs/kmcp/reference/kmcp-run) to run an MCP server on your local machine.
-* [kmcp secrets](/docs/kmcp/reference/kmcp-secrets) to create Kubernetes secrets for the environment variables that you want to use in your MCP server.
\ No newline at end of file
+
+
+
Reference
+
Review the KMCP commands and learn how to use them effectively.
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/config/navigation.json b/src/config/navigation.json
index 0a156c76..0271f16a 100644
--- a/src/config/navigation.json
+++ b/src/config/navigation.json
@@ -83,11 +83,6 @@
"title": "Tools",
"href": "/docs/kagent/concepts/tools",
"description": "Understand the different types of tools kagent can use, including built-in, MCP, and HTTP tools, and how tool discovery works."
- },
- {
- "title": "Memory",
- "href": "/docs/kagent/concepts/memory",
- "description": "Learn how kagent agents manage memory and conversation history to maintain context and improve interactions."
}
]
},