diff --git a/src/app/docs/kagent/concepts/agent-memory/page.mdx b/src/app/docs/kagent/concepts/agent-memory/page.mdx new file mode 100644 index 0000000..bd4f059 --- /dev/null +++ b/src/app/docs/kagent/concepts/agent-memory/page.mdx @@ -0,0 +1,104 @@ +--- +title: "Agent Memory" +pageOrder: 5 +description: "Enable vector-backed long-term memory for agents to learn from past interactions." +--- + +export const metadata = { + title: "Agent Memory", + description: "Enable vector-backed long-term memory for agents to learn from past interactions.", + author: "kagent.dev" +}; + +# Agent Memory + +kagent provides long-term memory for agents using vector similarity search. Agents can automatically save and retrieve relevant context across conversations. + +## Overview + +Memory in kagent is: +- **Vector-backed** — Uses embedding models to encode memories as 768-dimensional vectors +- **Searchable** — Retrieves relevant memories via cosine similarity +- **Automatic** — Extracts and saves memories periodically without explicit user action +- **Time-bounded** — Memories expire after a configurable TTL (default 15 days) + +## Supported Storage Backends + +| Backend | Description | +|---------|-------------| +| **pgvector** (PostgreSQL) | Full-featured vector search using the pgvector extension | +| **Turso/libSQL** (SQLite) | Lightweight alternative using SQLite-compatible storage | + +## Configuration + +### Enable Memory on an Agent + +```yaml +apiVersion: kagent.dev/v1alpha2 +kind: Agent +metadata: + name: memory-agent +spec: + type: Declarative + declarative: + modelConfig: default-model-config + systemMessage: "You are a helpful assistant with long-term memory." + memory: + enabled: true + embeddingProvider: + type: OpenAI + model: text-embedding-3-small +``` + +### Memory with Separate Embedding Provider + +```yaml +memory: + enabled: true + embeddingProvider: + type: OpenAI + model: text-embedding-3-small + secretRef: + name: openai-embedding-key +``` + +## How Memory Works + +### Automatic Save Cycle + +1. The agent processes user messages normally +2. Every 5th user message, the agent automatically extracts key information +3. Extracted memories are summarized and encoded as embedding vectors +4. Vectors are stored in the database with metadata and timestamps + +### Memory Retrieval (Prefetch) + +Before generating a response, the agent: +1. Encodes the current user message as an embedding vector +2. Searches stored memories by cosine similarity +3. Injects the most relevant memories into the agent's context + +### Memory Tools + +When memory is enabled, three tools are injected into the agent: + +| Tool | Description | +|------|-------------| +| `save_memory` | Explicitly save a piece of information | +| `load_memory` | Search for relevant memories by query | +| `prefetch_memory` | Automatically run before response generation | + +## Memory Management via API + +``` +GET /api/memories/{agentId} # List memories +DELETE /api/memories/{agentId} # Clear all memories +DELETE /api/memories/{agentId}/{id} # Delete specific memory +``` + +## Technical Details + +- Embedding vectors are normalized to 768 dimensions +- Background TTL pruning runs periodically (default retention: 15 days) +- Memory is per-agent — each agent has its own isolated memory store +- Memories include timestamps and source session references diff --git a/src/app/docs/kagent/concepts/context-management/page.mdx b/src/app/docs/kagent/concepts/context-management/page.mdx new file mode 100644 index 0000000..c58ddb6 --- /dev/null +++ b/src/app/docs/kagent/concepts/context-management/page.mdx @@ -0,0 +1,57 @@ +--- +title: "Context Management" +pageOrder: 9 +description: "Automatically summarize older messages to stay within LLM context windows during long conversations." +--- + +export const metadata = { + title: "Context Management", + description: "Automatically summarize older messages to stay within LLM context windows during long conversations.", + author: "kagent.dev" +}; + +# Context Management + +Long conversations can exceed LLM context windows. kagent provides **event compaction** to automatically summarize older messages, preserving key information while reducing token count. + +## Configuration + +```yaml +apiVersion: kagent.dev/v1alpha2 +kind: Agent +metadata: + name: long-conversation-agent +spec: + type: Declarative + declarative: + modelConfig: default-model-config + systemMessage: "You are a helpful agent for extended sessions." + context: + eventsCompaction: + enabled: true +``` + +## How It Works + +1. As the conversation progresses, events accumulate in the session history +2. When the history approaches the model's context limit, compaction triggers +3. Older events are summarized while preserving: + - Key decisions and outcomes + - Important tool results + - Critical context from earlier in the conversation +4. The agent continues with the compacted history seamlessly + +## When to Use + +Enable event compaction when: +- Agents handle long-running conversations (debugging sessions, investigations) +- Agents call many tools that generate large outputs +- You want to support extended interactions without hitting context limits + +You may not need it for: +- Short, single-turn interactions +- Agents with small tool sets that generate compact outputs + +## Context Caching Note + +Prompt caching (a separate optimization that caches the prompt prefix for faster responses) is **not** configured at the agent level. Most LLM providers enable prompt caching by default. diff --git a/src/app/docs/kagent/concepts/git-based-skills/page.mdx b/src/app/docs/kagent/concepts/git-based-skills/page.mdx new file mode 100644 index 0000000..4e04a64 --- /dev/null +++ b/src/app/docs/kagent/concepts/git-based-skills/page.mdx @@ -0,0 +1,137 @@ +--- +title: "Git-Based Skills" +pageOrder: 8 +description: "Load markdown knowledge documents from Git repositories to guide agent behavior." +--- + +export const metadata = { + title: "Git-Based Skills", + description: "Load markdown knowledge documents from Git repositories to guide agent behavior.", + author: "kagent.dev" +}; + +# Git-Based Skills + +Skills are markdown-based knowledge documents that agents load at startup. They provide domain-specific instructions, best practices, and procedures that guide agent behavior. + +kagent supports two sources for skills: +- **OCI images** — Container images containing skill files (original approach) +- **Git repositories** — Clone skills directly from Git repos + +## Skill File Format + +Each skill is a directory containing a `SKILL.md` file with YAML frontmatter: + +```markdown +--- +name: kubernetes-troubleshooting +description: Guide for diagnosing and fixing common Kubernetes issues +--- + +# Kubernetes Troubleshooting + +## Pod Crash Loops + +When a pod is in CrashLoopBackOff: + +1. Check logs: `kubectl logs --previous` +2. Check events: `kubectl describe pod ` +3. Verify resource limits... +``` + +## Git Repository Configuration + +### Basic Example + +```yaml +apiVersion: kagent.dev/v1alpha2 +kind: Agent +metadata: + name: my-agent +spec: + type: Declarative + declarative: + modelConfig: default-model-config + systemMessage: "You are a helpful agent." + skills: + gitRefs: + - url: https://github.com/myorg/agent-skills.git + ref: main +``` + +### With Subdirectory + +```yaml +skills: + gitRefs: + - url: https://github.com/myorg/monorepo.git + ref: main + path: skills/kubernetes +``` + +### Multiple Sources + +Combine Git and OCI skills: + +```yaml +skills: + refs: + - image: ghcr.io/myorg/k8s-skills:latest + gitRefs: + - url: https://github.com/myorg/skills-repo.git + ref: main + - url: https://github.com/myorg/another-repo.git + ref: develop + path: agent-skills +``` + +## Authentication + +### HTTPS Token Auth + +```yaml +apiVersion: v1 +kind: Secret +metadata: + name: git-credentials +type: Opaque +stringData: + token: ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +``` + +```yaml +skills: + gitAuthSecretRef: + name: git-credentials + gitRefs: + - url: https://github.com/myorg/private-skills.git + ref: main +``` + +### SSH Key Auth + +```yaml +skills: + gitAuthSecretRef: + name: git-ssh-key + gitRefs: + - url: git@github.com:myorg/private-skills.git + ref: main +``` + +> A single `gitAuthSecretRef` applies to all Git repositories in the agent. All repos must use the same authentication method. + +## How It Works + +Under the hood, kagent uses a lightweight init container (~30MB) containing Git and krane tools: + +1. Before the agent pod starts, the `skills-init` container runs +2. It clones each Git repository to the skills volume +3. It also pulls any OCI skill images +4. The agent runtime discovers skills from the mounted volume at startup + +## Skill Discovery at Runtime + +Once loaded, skills are available through the built-in `SkillsTool`: +- **List skills:** The agent calls the tool with no arguments to see available skills +- **Load skill:** The agent calls the tool with a skill name to get the full content diff --git a/src/app/docs/kagent/concepts/human-in-the-loop/page.mdx b/src/app/docs/kagent/concepts/human-in-the-loop/page.mdx new file mode 100644 index 0000000..6d14344 --- /dev/null +++ b/src/app/docs/kagent/concepts/human-in-the-loop/page.mdx @@ -0,0 +1,130 @@ +--- +title: "Human-in-the-Loop" +pageOrder: 4 +description: "Configure tool approval workflows and the Ask User interactive tool for human oversight of agent actions." +--- + +export const metadata = { + title: "Human-in-the-Loop", + description: "Configure tool approval workflows and the Ask User interactive tool for human oversight of agent actions.", + author: "kagent.dev" +}; + +# Human-in-the-Loop (HITL) + +kagent implements Human-in-the-Loop functionality through two mechanisms: + +1. **Tool Approval** — Require user confirmation before executing sensitive tools +2. **Ask User** — Allow agents to interactively ask users questions during execution + +Both features pause agent execution and wait for user input before continuing. + +## Tool Approval + +### Overview + +Tool approval lets you mark specific tools as requiring user confirmation before execution. When an agent attempts to call an approval-required tool, execution pauses and the UI presents Approve/Reject buttons. + +This is useful for destructive or sensitive operations like: +- Deleting Kubernetes resources +- Writing files +- Executing shell commands +- Modifying infrastructure + +### Configuration + +Add `requireApproval` to your Agent's tool specification. The values must be a subset of `toolNames`: + +```yaml +apiVersion: kagent.dev/v1alpha2 +kind: Agent +metadata: + name: k8s-agent +spec: + type: Declarative + declarative: + modelConfig: default-model-config + systemMessage: "You are a Kubernetes management agent." + tools: + - type: McpServer + mcpServer: + name: kagent-tool-server + kind: RemoteMCPServer + toolNames: + - read_file + - write_file + - delete_file + requireApproval: + - delete_file + - write_file +``` + +In this example, `read_file` executes immediately, but `write_file` and `delete_file` will pause for user approval. + +### How It Works + +**Interrupt Phase:** +1. The agent calls a tool marked for approval +2. The ADK generates an `adk_request_confirmation` event +3. The UI receives the event and displays approval controls + +**Decision Phase:** +4. The user clicks **Approve** or **Reject** in the UI +5. Optionally, the user provides a rejection reason + +**Resume Phase:** +6. **Approved** tools execute normally and return results +7. **Rejected** tools return a rejection message — the LLM sees this and responds accordingly + +### Parallel Tool Approval + +When an agent generates multiple tool calls simultaneously, all pending approvals are presented together. Users can approve/reject individually or in batch. + +### Rejection Reasons + +When rejecting a tool call, users can provide a free-text explanation. This reason is passed back to the LLM as context, helping it understand why the tool was blocked and adjust its approach. + +--- + +## Ask User Tool + +The `ask_user` tool is a built-in tool automatically added to every agent. It allows agents to pose questions to users with optional predefined choices during execution. + +Use cases: +- Clarifying ambiguous user requests +- Offering choices between implementation approaches +- Collecting configuration preferences +- Getting confirmation on proposed plans + +### Question Types + +| Type | Configuration | UI Rendering | +|------|--------------|--------------| +| Single-select | `choices: [...]`, `multiple: false` | Choice chips (select one) | +| Multi-select | `choices: [...]`, `multiple: true` | Choice chips (select many) | +| Free-text | `choices: []` | Text input field | + +### No Configuration Required + +The `ask_user` tool is added unconditionally to every agent as a built-in tool. You don't need to add it to your Agent spec — it's always available. + +## Architecture Summary + +``` +User --> UI --> A2A Message --> Executor --> ADK --> Tool + | + request_confirmation() + | + <-- input_required --> + | +User <-- UI <-- A2A Event <-- Executor <---- ADK <----+ + | + v (Approve/Reject/Answer) + | +User --> UI --> A2A Message --> Executor --> ADK --> Tool (resumes) +``` + +Key design principles: +- **Deterministic replay** — Approved calls re-invoke via ADK preprocessor without additional LLM calls +- **Minimal custom logic** — The executor only handles the resume path +- **Unified mechanism** — Both tool approval and ask_user share the same `request_confirmation` infrastructure diff --git a/src/app/docs/kagent/concepts/multi-runtime/page.mdx b/src/app/docs/kagent/concepts/multi-runtime/page.mdx new file mode 100644 index 0000000..0fe4481 --- /dev/null +++ b/src/app/docs/kagent/concepts/multi-runtime/page.mdx @@ -0,0 +1,104 @@ +--- +title: "Multi-Runtime Support" +pageOrder: 7 +description: "Choose between Go and Python ADK runtimes for your agents." +--- + +export const metadata = { + title: "Multi-Runtime Support", + description: "Choose between Go and Python ADK runtimes for your agents.", + author: "kagent.dev" +}; + +# Multi-Runtime Support (Go / Python ADK) + +kagent supports two Agent Development Kit (ADK) runtimes for declarative agents. + +## Overview + +| Feature | Python ADK | Go ADK | +|---------|-----------|--------| +| Startup time | ~15 seconds | ~2 seconds | +| Ecosystem | Google ADK, LangGraph, CrewAI integrations | Native Go implementation | +| Resource usage | Higher (Python runtime) | Lower (compiled binary) | +| Default | Yes | No | +| Memory support | Yes | Yes | +| MCP support | Yes | Yes | +| HITL support | Yes | Yes | + +## Configuration + +### Python Runtime (Default) + +```yaml +apiVersion: kagent.dev/v1alpha2 +kind: Agent +metadata: + name: python-agent +spec: + type: Declarative + declarative: + runtime: python + modelConfig: default-model-config + systemMessage: "You are a helpful agent." +``` + +### Go Runtime + +```yaml +apiVersion: kagent.dev/v1alpha2 +kind: Agent +metadata: + name: go-agent +spec: + type: Declarative + declarative: + runtime: go + modelConfig: default-model-config + systemMessage: "You are a fast-starting agent." +``` + +## When to Use Which + +**Choose Go when:** +- Fast startup matters (autoscaling, cold starts) +- Lower resource consumption is important +- You don't need Python-specific framework integrations + +**Choose Python when:** +- You need Google ADK-native features +- You want to use CrewAI, LangGraph, or OpenAI framework integrations +- You need Python-based custom tools or skills + +## Go ADK Built-in Tools + +| Tool | Description | +|------|-------------| +| `SkillsTool` | Discover and load skills from the skills directory | +| `BashTool` | Execute shell commands with timeout handling | +| `ReadFile` | Read file contents with line numbers and pagination | +| `WriteFile` | Write content to files (creates directories as needed) | +| `EditFile` | String replacement with ambiguity detection | + +## BYO (Bring Your Own) Agents + +For maximum flexibility, bring your own agent container: + +```yaml +apiVersion: kagent.dev/v1alpha2 +kind: Agent +metadata: + name: custom-agent +spec: + type: BYO + byo: + image: myregistry/my-custom-agent:v1.0 + deployment: + replicas: 1 + resources: + requests: + memory: "512Mi" + cpu: "500m" +``` + +BYO agents must implement the A2A protocol endpoint for communication with the kagent platform. diff --git a/src/app/docs/kagent/concepts/prompt-templates/page.mdx b/src/app/docs/kagent/concepts/prompt-templates/page.mdx new file mode 100644 index 0000000..af3a5ab --- /dev/null +++ b/src/app/docs/kagent/concepts/prompt-templates/page.mdx @@ -0,0 +1,102 @@ +--- +title: "Prompt Templates" +pageOrder: 6 +description: "Use Go template syntax to compose reusable prompt fragments from ConfigMaps." +--- + +export const metadata = { + title: "Prompt Templates", + description: "Use Go template syntax to compose reusable prompt fragments from ConfigMaps.", + author: "kagent.dev" +}; + +# Prompt Templates + +kagent supports Go `text/template` syntax in Agent system messages, enabling composition from reusable fragments stored in ConfigMaps. + +## Overview + +Instead of duplicating safety guidelines and tool usage instructions in every agent, you can: +1. Store common prompt fragments in ConfigMaps +2. Reference them using `{{include "source/key"}}` syntax +3. Use agent context variables for dynamic interpolation + +Template resolution happens during controller reconciliation — the final system message is fully expanded before reaching the agent runtime. + +## Built-in Prompt Templates + +kagent ships a `kagent-builtin-prompts` ConfigMap with five reusable templates: + +| Template Key | Description | +|-------------|-------------| +| `skills-usage` | Instructions for discovering and using skills | +| `tool-usage-best-practices` | Best practices for tool invocation | +| `safety-guardrails` | Safety and operational guardrails | +| `kubernetes-context` | Kubernetes-specific operational context | +| `a2a-communication` | Agent-to-agent communication guidelines | + +## Usage + +```yaml +apiVersion: kagent.dev/v1alpha2 +kind: Agent +metadata: + name: k8s-agent +spec: + type: Declarative + declarative: + modelConfig: default-model-config + promptTemplate: + dataSources: + - configMapRef: + name: kagent-builtin-prompts + - configMapRef: + name: my-custom-prompts + systemMessage: | + You are a Kubernetes management agent named {{.AgentName}}. + + {{include "kagent-builtin-prompts/safety-guardrails"}} + {{include "kagent-builtin-prompts/tool-usage-best-practices"}} + {{include "my-custom-prompts/k8s-specific-rules"}} + + Your tools: {{.ToolNames}} + Your skills: {{.SkillNames}} +``` + +### Available Template Variables + +| Variable | Description | +|----------|-------------| +| `{{.AgentName}}` | Name of the Agent resource | +| `{{.AgentNamespace}}` | Namespace of the Agent resource | +| `{{.Description}}` | Agent description | +| `{{.ToolNames}}` | Comma-separated list of tool names | +| `{{.SkillNames}}` | Comma-separated list of skill names | + +### Creating Custom Prompt Templates + +```yaml +apiVersion: v1 +kind: ConfigMap +metadata: + name: my-custom-prompts +data: + incident-response: | + ## Incident Response Guidelines + When responding to incidents: + 1. Assess the severity (P1-P4) + 2. Check affected services and dependencies + 3. Review recent deployments and changes + 4. Collect relevant logs and metrics + 5. Propose remediation steps +``` + +## How It Works + +1. The controller watches ConfigMaps referenced in `promptTemplate.dataSources` +2. During reconciliation, `{{include "configmap-name/key"}}` directives are resolved +3. Template variables are interpolated +4. The fully expanded system message is written to the ADK config +5. ConfigMap changes trigger automatic re-reconciliation + +> **Security Note:** Only ConfigMaps are supported as data sources — Secret references were intentionally excluded to avoid leaking sensitive data into prompts sent to LLM providers. diff --git a/src/app/docs/kagent/concepts/tools-ecosystem/page.mdx b/src/app/docs/kagent/concepts/tools-ecosystem/page.mdx new file mode 100644 index 0000000..133b562 --- /dev/null +++ b/src/app/docs/kagent/concepts/tools-ecosystem/page.mdx @@ -0,0 +1,204 @@ +--- +title: "Tools Ecosystem" +pageOrder: 3 +description: "Explore the built-in MCP tools for Kubernetes, Helm, Istio, Prometheus, Grafana, Cilium, and Argo Rollouts." +--- + +export const metadata = { + title: "Tools Ecosystem", + description: "Explore the built-in MCP tools for Kubernetes, Helm, Istio, Prometheus, Grafana, Cilium, and Argo Rollouts.", + author: "kagent.dev" +}; + +# Tools Ecosystem + +kagent provides a rich set of built-in tools through MCP (Model Context Protocol) servers, plus the ability to add custom tools. All tools are integrated via the kagent-tools package. + +## Built-in Tool Categories + +### Kubernetes + +Comprehensive cluster management tools: + +| Tool | Description | +|------|-------------| +| `kubectl_get` | Query resources (pods, deployments, services, etc.) | +| `kubectl_describe` | Detailed resource information | +| `kubectl_scale` | Scale deployments and statefulsets | +| `kubectl_patch` | Patch resources with strategic merge | +| `kubectl_label` | Add/remove labels | +| `kubectl_annotate` | Add/remove annotations | +| `kubectl_delete` | Delete resources | +| `kubectl_apply` | Apply YAML manifests | +| `kubectl_exec` | Execute commands in pods | +| `kubectl_logs` | Retrieve pod logs | +| `kubectl_events` | Get cluster events | +| `kubectl_connectivity_test` | Test service connectivity | + +### Helm + +| Tool | Description | +|------|-------------| +| `helm_list` | List installed releases | +| `helm_install` | Install a chart | +| `helm_upgrade` | Upgrade a release | +| `helm_uninstall` | Remove a release | +| `helm_repo_add` | Add chart repository | +| `helm_repo_update` | Update chart repositories | + +### Istio + +| Tool | Description | +|------|-------------| +| `istio_proxy_status` | Check proxy synchronization status | +| `istio_proxy_config` | Inspect proxy configuration | +| `istio_install` | Install Istio | +| `istio_manifest_generate` | Generate installation manifests | +| `istio_analyze` | Analyze Istio configuration for issues | +| `istio_version` | Get Istio version info | +| `istio_remote_clusters` | Manage remote cluster configuration | +| `istio_waypoint` | Manage waypoint proxies | + +### Argo Rollouts + +| Tool | Description | +|------|-------------| +| `argo_rollouts_verify` | Verify controller is running | +| `argo_rollouts_check_plugins` | Check installed plugins | +| `argo_rollouts_promote` | Promote a rollout | +| `argo_rollouts_pause` | Pause a rollout | +| `argo_rollouts_set_image` | Update rollout image | + +### Cilium + +| Tool | Description | +|------|-------------| +| `cilium_status` | Check Cilium status | +| `cilium_install` | Install Cilium | +| `cilium_upgrade` | Upgrade Cilium | +| `cilium_clustermesh` | Manage cluster mesh | +| `cilium_bgp_peers` | View BGP peers | +| `cilium_bgp_routes` | View BGP routes | + +### Prometheus + +| Tool | Description | +|------|-------------| +| `prometheus_query` | Execute instant PromQL queries | +| `prometheus_query_range` | Execute range PromQL queries | +| `prometheus_labels` | Discover available labels | +| `prometheus_targets` | List scrape targets and status | + +### Grafana + +| Tool | Description | +|------|-------------| +| `grafana_orgs` | Manage organizations | +| `grafana_dashboards` | List/manage dashboards | +| `grafana_alerts` | View/manage alerts | +| `grafana_datasources` | Manage data sources | + +### Utilities + +| Tool | Description | +|------|-------------| +| `datetime_format` | Format timestamps | +| `datetime_parse` | Parse date strings | +| `shell_execute` | Run shell commands | +| `docs_query` | Query product documentation | + +## Agent Built-in Tools + +These tools are automatically available to every agent (no configuration needed): + +| Tool | Description | +|------|-------------| +| `ask_user` | Pose questions to users with optional choices | +| `SkillsTool` | Discover and load skills | +| `BashTool` | Execute shell commands (Go ADK) | +| `ReadFile` | Read files with pagination (Go ADK) | +| `WriteFile` | Write file content (Go ADK) | +| `EditFile` | Edit files via string replacement (Go ADK) | + +## Configuring Tools on an Agent + +### Single MCP Server + +```yaml +apiVersion: kagent.dev/v1alpha2 +kind: Agent +metadata: + name: k8s-agent +spec: + type: Declarative + declarative: + modelConfig: default-model-config + systemMessage: "You manage Kubernetes clusters." + tools: + - type: McpServer + mcpServer: + name: kagent-tool-server + kind: RemoteMCPServer + toolNames: + - kubectl_get + - kubectl_describe + - kubectl_logs + - kubectl_events +``` + +### With Tool Approval + +```yaml +tools: + - type: McpServer + mcpServer: + name: kagent-tool-server + kind: RemoteMCPServer + toolNames: + - kubectl_get + - kubectl_describe + - kubectl_delete + - kubectl_apply + requireApproval: + - kubectl_delete + - kubectl_apply +``` + +### Agent as Tool (A2A) + +Use another agent as a tool via the A2A protocol: + +```yaml +tools: + - type: Agent + agent: + name: specialist-agent + namespace: default +``` + +## Community / Contrib MCP Servers + +Additional MCP servers available in `contrib/tools/`: + +| Server | Description | +|--------|-------------| +| **GitHub MCP Server** | GitHub Copilot MCP server with tools for issues, PRs, repos, actions, and more | +| **k8sgpt MCP Server** | K8sGPT integration for AI-powered Kubernetes diagnostics | +| **Grafana MCP** | Extended Grafana integration | + +## Read-Only Mode + +kagent-tools supports a read-only mode for safer operation: + +```yaml +# In Helm values +kagentTools: + readOnly: true # Disables all write/mutating operations +``` + +## Observability + +kagent-tools exposes Prometheus metrics for monitoring: +- Tool invocation counts +- Tool execution duration +- Error rates by tool diff --git a/src/config/navigation.json b/src/config/navigation.json index 98dcb2c..b72a0eb 100644 --- a/src/config/navigation.json +++ b/src/config/navigation.json @@ -83,6 +83,41 @@ "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": "Tools Ecosystem", + "href": "/docs/kagent/concepts/tools-ecosystem", + "description": "Comprehensive catalog of built-in tools for Kubernetes, Helm, Istio, Prometheus, Grafana, Cilium, and Argo Rollouts." + }, + { + "title": "Human-in-the-Loop", + "href": "/docs/kagent/concepts/human-in-the-loop", + "description": "Configure tool approval gates and interactive user prompts for agent oversight." + }, + { + "title": "Agent Memory", + "href": "/docs/kagent/concepts/agent-memory", + "description": "Enable vector-backed long-term memory for agents using pgvector or Turso." + }, + { + "title": "Prompt Templates", + "href": "/docs/kagent/concepts/prompt-templates", + "description": "Compose reusable prompt fragments from ConfigMaps using Go template syntax." + }, + { + "title": "Multi-Runtime Support", + "href": "/docs/kagent/concepts/multi-runtime", + "description": "Choose between Go and Python ADK runtimes for your agents." + }, + { + "title": "Git-Based Skills", + "href": "/docs/kagent/concepts/git-based-skills", + "description": "Load markdown knowledge documents from Git repositories to guide agent behavior." + }, + { + "title": "Context Management", + "href": "/docs/kagent/concepts/context-management", + "description": "Automatically summarize older messages to stay within LLM context windows." } ] }, @@ -254,7 +289,7 @@ "href": "/docs/kagent/resources/helm", "description": "kagent Helm chart configuration reference" }, - { +{ "title": "FAQs", "href": "/docs/kagent/resources/faq", "description": "Find answers to frequently asked questions about kagent."