dsh-agora 0.2.0

package/assets/agora/references/conversational-ai/architecture.md

@@ -0,0 +1,221 @@
+---
+name: conversational-ai-architecture
+description: |
+  System architecture and call sequence for Agora Conversational AI agents. Use when the user
+  asks how ConvoAI works, what components are involved, initialization order, token flow,
+  agent lifecycle, start/stop sequence, or how server, client, RTC, RTM, and the ConvoAI
+  platform fit together.
+license: MIT
+metadata:
+  author: agora
+  version: '1.0.0'
+---
+
+# ConvoAI Architecture and Call Sequence
+
+Read this file first when the user asks how a ConvoAI voice agent is wired end to end, what calls happen in what order, or how to manage agent lifecycle across server and client.
+
+For implementation details after the architecture is clear:
+
+| Topic                                      | File                                                     |
+| ------------------------------------------ | -------------------------------------------------------- |
+| Token types and auth headers               | [auth-flow.md](auth-flow.md)                             |
+| Server SDK session management              | [server-sdks.md](server-sdks.md)                         |
+| RTC + RTM + ConvoAI init order and cleanup | [../integration-patterns.md](../integration-patterns.md) |
+| Client transcripts, state, sendText        | [agent-toolkit.md](agent-toolkit.md)                     |
+| REST endpoint schemas                      | [README.md](README.md) + OpenAPI spec                    |
+| Official quickstart source code            | [quickstarts.md](quickstarts.md)                         |
+
+## System Components
+
+```text
+┌──────────────────────┐     start/stop session      ┌─────────────────┐    REST /join,/leave,/update   ┌──────────────────────┐
+│ Browser/Mobile App   │ ──────────────────────────► │   Your Server   │ ─────────────────────────────► │ Agora ConvoAI Engine │
+│ UI + app state       │ ◄──── channel + tokens ──── │  (app backend)  │ ◄────── agent_id,status ────── │  manages agent       │
+└──────────┬───────────┘                             └─────────────────┘                                └──────────┬───────────┘
+           │ uses RTC/RTM SDKs                                                                          creates/updates/stops
+           ▼                                                                                                      ▼
+┌──────────────────────┐                                                                    ┌──────────────────────┐
+│ Agora RTC + RTM SDKs │                                                                    │   ConvoAI Agent      │
+│ client-side runtime  │                                                                    │ managed participant  │
+└──────────┬───────────┘                                                                    └──────────┬───────────┘
+           │ joins/publishes/subscribes                                                                │ joins/publishes/subscribes
+           ▼                                                                                           ▼
+┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
+│                                      Agora Realtime Channels (SDRTN)                                           │
+│  RTC channel: client mic audio flows to the agent; agent TTS audio flows back to the client                    │
+│  RTM channel: transcripts, agent state, metrics, errors, and control messages use the same channel name        │
+└────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
+```
+
+Roles:
+
+- **Your server** starts and stops agents, mints client tokens, and owns session state in your app.
+- **ConvoAI Engine** manages the agent lifecycle and pipeline (speech in → ASR → LLM → TTS → speech out).
+- **ConvoAI agent** is the managed realtime participant created by the engine. It joins the same RTC channel as the client and can publish RTM events to the matching RTM channel when enabled.
+- **Client app** triggers the app backend to start/stop the agent. The app itself sits above the Agora RTC/RTM SDKs.
+- **Agora RTC/RTM SDKs and the ConvoAI agent communicate through Agora realtime channels.** The channels are the lowest-level transport layer in this architecture.
+
+The client toolkit does **not** start agents. The server does.
+
+## End-to-End Start Sequence
+
+Typical production flow when a user clicks "Start conversation":
+
+```text
+1. Client ──► Your server: "start session" (channel, user identity)
+2. Your server ──► Token builder: mint RTC token + RTM token for the user
+3. Your server ──► ConvoAI REST POST /join (or SDK session.start())
+4. ConvoAI Engine ──► creates agent, agent joins RTC channel (async)
+5. Your server ──► Client: { channel, rtcToken, rtmToken, agentId }
+6. Client ──► RTM login + subscribe to channel
+7. Client ──► RTC join(channel, rtcToken, uid)
+8. Client waits for agent RTC user-joined / agent audio before treating session as live
+9. User speaks ──► agent hears via RTC ──► agent responds via RTC
+10. Transcripts/state arrive via RTM (if enabled) or RTC data channel
+```
+
+Important timing rules:
+
+- `POST /join` success means the request was accepted, not that the agent is already in the channel. Wait for RTC `user-joined` or SDK/client agent-state events before expecting audio.
+- RTM channel name must match the RTC channel name passed in the join payload.
+- RTM login identity must match the RTM token subject.
+
+For auto-assigned RTC UIDs, join RTC first, read the assigned UID, then log into RTM with `String(rtcUid)`. See [../integration-patterns.md](../integration-patterns.md).
+
+## Initialization Order
+
+Default client-side order when the user's RTC UID is known up front:
+
+1. Initialize RTC engine/client (do not join yet)
+2. Initialize RTM and log in
+3. Subscribe to the RTM channel
+4. Call `POST /join` from your server
+5. Join the RTC channel
+
+Auto-assigned UID variant:
+
+1. Initialize RTC
+2. Join RTC and wait for assigned UID
+3. Log into RTM with `String(rtcUid)` and subscribe
+4. Call `POST /join` from your server
+
+## Tokens
+
+Three distinct tokens appear in most integrations:
+
+| Token                | Purpose                             | Used by                                        |
+| -------------------- | ----------------------------------- | ---------------------------------------------- |
+| RTC client token     | User joins RTC channel              | Browser/mobile RTC SDK                         |
+| RTM client token     | User logs into RTM                  | Browser/mobile RTM SDK                         |
+| ConvoAI server token | Authorize REST calls to ConvoAI API | Your server → `Authorization: agora token=...` |
+
+The agent also needs an RTC token in the join payload (`properties.token`). Your server generates it and passes it to ConvoAI when starting the agent.
+
+SDK users in App Credentials mode: pass `appId + appCertificate` to the server SDK and it generates the ConvoAI server token per request. You still mint the two client tokens yourself.
+
+See [auth-flow.md](auth-flow.md) and [../server/tokens.md](../server/tokens.md).
+
+## Agent Lifecycle
+
+### Platform agent status (REST)
+
+| Status     | Code | Meaning                    |
+| ---------- | ---- | -------------------------- |
+| IDLE       | 0    | Ready, not active          |
+| STARTING   | 1    | Initialization in progress |
+| RUNNING    | 2    | Active, processing audio   |
+| STOPPING   | 3    | Shutdown in progress       |
+| STOPPED    | 4    | Exited channel             |
+| RECOVERING | 5    | Error recovery             |
+| FAILED     | 6    | Execution failure          |
+
+### Server SDK session states
+
+When using `agora-agents`, map platform lifecycle to SDK session states:
+
+| SDK state           | Typical action                               |
+| ------------------- | -------------------------------------------- |
+| `idle`              | call `start()`                               |
+| `starting`          | wait                                         |
+| `running`           | `stop()`, `say()`, `interrupt()`, `update()` |
+| `stopping`          | wait                                         |
+| `stopped` / `error` | may call `start()` again                     |
+
+See [server-sdks.md](server-sdks.md).
+
+## Managing Agents
+
+Your server owns agent lifecycle. Common operations:
+
+| Operation           | REST                          | SDK equivalent                             |
+| ------------------- | ----------------------------- | ------------------------------------------ |
+| Start agent         | `POST /join`                  | `session.start()`                          |
+| Stop agent          | `POST /agents/{id}/leave`     | `session.stop()` or `client.stopAgent(id)` |
+| Update config/token | `POST /agents/{id}/update`    | `session.update()`                         |
+| Query status        | `GET /agents/{id}`            | platform query                             |
+| List agents         | `GET /agents`                 | platform query                             |
+| Broadcast speech    | `POST /agents/{id}/speak`     | `session.say()`                            |
+| Interrupt speech    | `POST /agents/{id}/interrupt` | `session.interrupt()`                      |
+
+Production patterns:
+
+- **Stateful server**: hold `AgentSession` in memory; use in-process SDK events.
+- **Stateless server**: store `agent_id` in your DB; use platform webhooks or poll `GET /agents/{id}` for state changes.
+- **Client UI**: subscribe to RTM agent events for transcripts and live state in the browser.
+
+Fetch full request/response schemas from the OpenAPI spec — do not invent fields:
+
+```text
+GET https://docs-md.agora.io/api/conversational-ai-api-v2.x.yaml
+```
+
+## RTM Event Delivery
+
+To receive transcripts and agent state in the client via RTM, both join flags are required:
+
+```json
+{
+  "advanced_features": { "enable_rtm": true },
+  "parameters": { "data_channel": "rtm" }
+}
+```
+
+Without both, events may arrive via RTC data channel instead, and RTM toolkit handlers will not fire.
+
+Optional flags:
+
+- `parameters.enable_metrics: true` for metrics events
+- `parameters.enable_error_message: true` for error events
+
+## Stop and Cleanup Sequence
+
+Reverse initialization on session end:
+
+1. Stop the agent from your server (`POST /leave` or SDK `stop()`)
+2. Client leaves RTC channel
+3. Client unsubscribes from RTM channel
+4. Client logs out of RTM
+5. Release RTC/RTM engines
+
+Stopping the agent before the client leaves gives the platform time to exit the channel cleanly.
+
+## Where Code Lives
+
+| Layer                    | Responsibility                      | Typical source                                                  |
+| ------------------------ | ----------------------------------- | --------------------------------------------------------------- |
+| Server start/stop/update | Agent lifecycle, token minting      | Official quickstart backend or [server-sdks.md](server-sdks.md) |
+| Client RTC join          | Audio in/out                        | Official quickstart frontend or RTC refs                        |
+| Client RTM + toolkit     | Transcripts, state, sendText        | [agent-toolkit.md](agent-toolkit.md)                            |
+| Join payload shape       | LLM/TTS/ASR config, channel, tokens | Official quickstart or OpenAPI spec                             |
+
+When adapting into an existing app, use [integration-from-quickstart.md](integration-from-quickstart.md) to map quickstart source files to your app paths before editing.
+
+## Common Mistakes
+
+- Generating `/join` payloads from memory instead of copying from the official quickstart source.
+- Treating `POST /join` response as proof the agent is already audible in RTC.
+- Using one RTC token for both the client and the ConvoAI `Authorization` header.
+- Mismatching RTM login identity and RTM token subject.
+- Enabling RTM in the project but omitting both RTM join flags.
+- Calling client toolkit init before the server has started an agent.

package/assets/agora/references/conversational-ai/auth-flow.md

@@ -0,0 +1,154 @@
+---
+name: agora-convoai-auth-flow
+description: |
+  End-to-end token and authentication flow for Agora Conversational AI — for implementors
+  calling the REST API directly (Java, Ruby, PHP, C#, or any language without an SDK).
+  The TypeScript/Python/Go SDKs handle ConvoAI token generation automatically in App
+  Credentials mode — use server-sdks.md for those.
+  Use this file when: the user needs to understand which token goes where, is building a
+  non-SDK backend, or explicitly asks about token types / buildTokenWithRtm / auth flow.
+  Triggers on: RTC token, RTM token, ConvoAI token, token flow, auth flow, buildTokenWithRtm,
+  three tokens, REST API auth, Java backend, direct REST.
+license: MIT
+metadata:
+  author: agora
+  version: '1.0.0'
+---
+
+# ConvoAI Auth Flow — End to End
+
+> **Architecture first:** For the full system diagram, start/stop sequence, and component roles, read [architecture.md](architecture.md).
+
+> **SDK users:** If you are using the TypeScript, Python, or Go SDK, you do not need to implement this flow manually. Pass `appId + appCertificate` to the SDK client and it generates the ConvoAI token per request automatically. See [server-sdks.md](server-sdks.md). This file is for backends calling the REST API directly.
+
+Three separate tokens exist in a ConvoAI integration. Developers routinely confuse them because they all use the same App ID + App Certificate as inputs.
+
+## The Three Tokens
+
+| Token | Generated by | Used by | Where |
+|-------|-------------|---------|-------|
+| **RTC client token** | Your server | Browser / mobile RTC client | `rtcClient.join(appId, channel, token, uid)` |
+| **RTM client token** | Your server | Browser / mobile RTM client | `rtmClient.login({ token })` |
+| **ConvoAI server token** | SDK (App Credentials mode) or you (Token Auth mode) | Your server → ConvoAI REST API | `Authorization: agora token=<value>` |
+
+The **ConvoAI server token** is a combined RTC + RTM token generated with `RtcTokenBuilder.buildTokenWithRtm()`. It is **not** the same as the RTC token the client uses to join the channel — even though both use the same builder.
+
+## Sequence Diagram
+
+```
+Your Server          ConvoAI Platform          Browser Client
+     |                      |                        |
+     |-- POST /join -------->|                        |
+     |   Authorization:      |                        |
+     |   agora token=<convoAI token>                  |
+     |                  agent starts                  |
+     |<-- agentId -----------|                        |
+     |                       |                        |
+     |-- RTC token + RTM token ---------------------->|
+     |                       |                        |
+     |                       |<-- rtcClient.join() ---|
+     |                       |<-- rtmClient.login() --|
+     |                       |                        |
+     |                       |<==== RTC audio =======>|
+     |                       |<==== RTM messages ====>|
+```
+
+## Worked Example
+
+### 1. Your server generates client tokens
+
+```typescript
+import { RtcTokenBuilder, RtmTokenBuilder, RtcRole } from 'agora-token';
+
+const uid = 12345;             // user's numeric UID
+const channel = 'my-channel';
+const expiry = 3600;           // 1 hour
+
+// RTC token — for the client to join the RTC channel
+const rtcToken = RtcTokenBuilder.buildTokenWithUid(
+  appId, appCertificate, channel, uid, RtcRole.PUBLISHER,
+  expiry, expiry
+);
+
+// RTM token — for the client to log into RTM (required for sendText/interrupt)
+const rtmToken = RtmTokenBuilder.buildToken(
+  appId, appCertificate, String(uid), expiry
+);
+```
+
+### 2. Your server starts the agent
+
+Using App Credentials mode — the SDK generates the ConvoAI token automatically:
+
+```typescript
+import { AgoraClient, Agent } from 'agora-agents';
+
+const client = new AgoraClient({
+  appId: process.env.AGORA_APP_ID,
+  appCertificate: process.env.AGORA_APP_CERTIFICATE, // SDK handles ConvoAI token
+});
+
+const session = agent.createSession({ channel, agentUid: 0 });
+const agentId = await session.start(); // ConvoAI token generated internally per request
+```
+
+Using Token Auth mode — you generate the ConvoAI token yourself:
+
+```typescript
+// ConvoAI token = combined RTC + RTM token, bound to the agent's uid on the channel
+const convoAIToken = RtcTokenBuilder.buildTokenWithRtm(
+  appId, appCertificate, channel,
+  'agent-account',   // use account (string) not numeric uid for the agent
+  RtcRole.PUBLISHER,
+  expiry, expiry
+);
+
+const client = new AgoraClient({
+  appId: process.env.AGORA_APP_ID,
+  authToken: convoAIToken,  // reused for every request until you replace it
+});
+```
+
+### 3. Your server returns client tokens to the browser
+
+```typescript
+// Express handler example
+app.post('/start-session', async (req, res) => {
+  const { uid, channel } = req.body;
+
+  const rtcToken = /* generate as above */;
+  const rtmToken = /* generate as above */;
+  const agentId = await session.start();
+
+  res.json({ rtcToken, rtmToken, agentId, channel });
+});
+```
+
+### 4. Browser initializes with both tokens
+
+```typescript
+import AgoraRTC from 'agora-rtc-sdk-ng';
+import AgoraRTM from 'agora-rtm';
+import { AgoraVoiceAI } from 'agora-agent-client-toolkit';
+
+const { rtcToken, rtmToken, channel } = await fetch('/start-session', { ... }).then(r => r.json());
+
+const rtcClient = AgoraRTC.createClient({ mode: 'rtc', codec: 'vp8' });
+const rtmClient = new AgoraRTM.RTM(appId, String(uid));
+await rtmClient.login({ token: rtmToken });  // RTM token here
+
+const ai = await AgoraVoiceAI.init({
+  rtcEngine: rtcClient,
+  rtmConfig: { rtmEngine: rtmClient },
+});
+
+await rtcClient.join(appId, channel, rtcToken, uid);  // RTC token here
+```
+
+**Identity rule:** the RTM client identity must match the identity the RTM token was minted for. If your backend minted `rtmToken` for `String(uid)`, do not create the RTM client with a different random user ID. In first-success paths, this kind of mismatch can surface as generic startup failures rather than a clear token error.
+
+## App Credentials Shortcut
+
+With `appId + appCertificate` passed to `AgoraClient`, the SDK generates the ConvoAI token per request. The developer only needs to manage the two client-side tokens (RTC + RTM). This is the recommended path for production.
+
+App Certificate never leaves your server in either case — the browser only ever receives the scoped RTC and RTM tokens.

package/assets/agora/references/conversational-ai/conversational-ai-studio.md

@@ -0,0 +1,173 @@
+# ConvoAI Studio Agent ID
+
+Use this file when the user already has an **Agora Studio Agent ID** from:
+
+<https://console.agora.io/studio/agents>
+
+This is the Agora-version analogue of a preconfigured agent path: the Studio-managed agent
+configuration already exists, so quickstart should avoid rebuilding the provider stack from
+scratch unless the user explicitly asks to replace it.
+
+## What It Is
+
+- **Studio Agent ID**: identifies an agent configuration created or managed in Agora Studio.
+- **Runtime `agent_id`**: identifies a live started agent session returned by the ConvoAI REST API.
+- **Request field mapping**: when reusing an Agora Studio-managed agent in the start flow, pass the Studio Agent ID via the request field `pipeline_id`.
+
+These are **not** interchangeable.
+
+## When to Use This Path
+
+Use the Studio Agent ID path when:
+
+- the user explicitly says they already have an Agent ID from the Studio Agents page
+- the user wants to reuse an agent configured in Studio
+- the user does not want to re-enter STT / LLM / TTS provider details during quickstart
+
+Do **not** use this path when:
+
+- the user only has the runtime `agent_id` returned by `/join`
+- the user still needs to choose or build the provider stack from scratch
+
+## Quickstart Rules
+
+If the Studio Agent ID path is chosen:
+
+1. Treat Agora Studio as the source of truth for the agent configuration.
+2. Do not re-ask provider-vendor questions unless the user explicitly wants to replace the Studio-managed config.
+3. Keep the client and auth path aligned with the chosen quickstart baseline (`full-stack-nextjs`, `separate-backend-frontend`, or `existing-app-integration`).
+4. Use the Studio Agent ID as `pipeline_id` in the request body.
+5. Before generating exact request code, still verify the current official ConvoAI docs for any other request-shape changes. Do not fabricate undocumented fields beyond the confirmed `pipeline_id` mapping.
+
+For an existing app, still use the official quickstart as the Studio-managed source path first. After the source is inspected, use [integration-from-quickstart.md](integration-from-quickstart.md) to detect the app shape and create a copy map before editing the existing app. Runtime proof is required before claiming the integrated app works.
+
+## Goal
+
+Reuse the official sample repo as the structural baseline, but replace the default provider-selection path with the user's existing Studio-managed agent path.
+
+This flow is for implementation after quickstart confirms the user already has a Studio Agent ID. Do not send the user back to provider selection unless they explicitly want to replace the Studio-managed config.
+
+## User-Facing Guidance
+
+Suggested explanation:
+
+```text
+If you already configured the agent in Agora Studio, we can treat Studio as the source of truth for the agent configuration and avoid rebuilding the provider stack from scratch here.
+
+Open `https://console.agora.io/studio/agents`, find the agent you want to reuse, and copy its Agent ID.
+```
+
+## Request Shape Rule
+
+For this Studio path, use the same request-field convention as the parallel preconfigured-agent flow:
+
+- copy the **Agent ID** from `https://console.agora.io/studio/agents`
+- pass that value as `pipeline_id` in the request body
+
+In other words:
+
+- **Studio UI name**: `Agent ID`
+- **Request field name**: `pipeline_id`
+
+## Current Request Shape
+
+Current fixed request shape for the Studio Agent ID path:
+
+```text
+POST https://api.agora.io/api/conversational-ai-agent/v2/projects/{AGORA_APP_ID}/join
+Authorization: agora token={RTC_HEADER_TOKEN}
+Content-Type: application/json
+
+{
+  "name": "{channel}",
+  "pipeline_id": "{AGORA_STUDIO_AGENT_ID}",
+  "properties": {
+    "agent_rtc_uid": "{agent_rtc_uid}",
+    "channel": "{channel}",
+    "remote_rtc_uids": ["*"],
+    "token": "{RTC_AGENT_TOKEN}"
+  }
+}
+```
+
+Field mapping rules:
+
+| Request field | Source |
+|---|---|
+| URL project segment | Existing `AGORA_APP_ID` |
+| `Authorization` header token | RTC token generated with the caller/user UID using the sample's existing token-generation path |
+| `name` | Same value as `channel` |
+| `pipeline_id` | `AGORA_STUDIO_AGENT_ID` copied from `https://console.agora.io/studio/agents` |
+| `properties.agent_rtc_uid` | Runtime RTC UID string |
+| `properties.channel` | Runtime channel value |
+| `properties.remote_rtc_uids` | `["*"]` unless the user asks for specific UIDs |
+| `properties.token` | Separate RTC token generated with the agent UID using the sample's existing token-generation path |
+
+Do not reintroduce the old provider-based `llm`, `tts`, or `asr` request blocks in this Studio-managed path.
+Do not reuse one RTC token for both the `Authorization` header and `properties.token`.
+
+## Expected Success Response
+
+Code generated for this flow should expect and preserve the standard live-agent response fields:
+
+- `agent_id`
+- `create_ts`
+- `status`
+
+## Minimum Contract
+
+For the Studio-managed path, the skill may assume:
+
+- the Studio Agent ID value is supplied by the user
+- that value maps to `pipeline_id`
+- the runtime `agent_id` is still returned by the live start/join flow and must not be confused with the Studio Agent ID
+
+## Env and Config Rules
+
+- Prefer `AGORA_STUDIO_AGENT_ID` as the config key / placeholder name in code or env templates.
+- Reuse the sample's existing `AGORA_APP_ID` and token-generation path.
+- Remove or bypass provider-only config when it is only used for the old three-stage selection flow.
+- Keep the sample's existing config style; do not invent a second config-loading layer just for `AGORA_STUDIO_AGENT_ID`.
+- Treat `AGORA_STUDIO_AGENT_ID` as a user-filled config value. Add the placeholder, but do not ask the user to paste the live value into the conversation after it has already been identified.
+
+## Implementation Guardrails
+
+- Do not confuse the Studio Agent ID with the runtime `agent_id`.
+- Do not replace `pipeline_id` with `agent_id` in request generation.
+- Do not hardcode the `Authorization` token or the RTC `properties.token`; both must come from the runtime token path.
+- Before code generation, fetch the current official ConvoAI docs / OpenAPI and verify:
+  - any other required body fields around `pipeline_id`
+  - whether Studio-managed agents require additional prerequisites or restrictions
+  - the current response shape
+
+## Implementation Workflow
+
+1. Keep the chosen quickstart baseline (`full-stack-nextjs`, `separate-backend-frontend`, or `existing-app-integration`) as the structural baseline.
+2. Inspect the repo's actual env/config files and the current request path that starts the agent.
+3. Replace only the provider-selection-specific request/config path with the fixed Studio Agent ID request shape in this file.
+4. Generate the new request code from the fixed shape above, preserving:
+   - `POST /api/conversational-ai-agent/v2/projects/{appId}/join`
+   - `Authorization: agora token=...`
+   - JSON body with `name`, `pipeline_id`, and `properties`
+5. Map dynamic fields to runtime/config sources:
+   - `name` → same value as `channel`
+   - `pipeline_id` → `AGORA_STUDIO_AGENT_ID`
+   - URL project segment → `AGORA_APP_ID`
+   - `Authorization` header token → RTC token generated with the caller/user UID
+   - `properties.token` → separate RTC token generated with the agent UID
+   - `channel` / `agent_rtc_uid` → runtime values
+6. Parse and preserve `agent_id`, `create_ts`, and `status` from the response.
+7. Keep the rest of the repo structure and RTC/UI flow as close to the sample as possible.
+
+## After This Step
+
+Once the Studio Agent ID is collected:
+
+- keep quickstart in the selected baseline path
+- for existing apps, continue through [integration-from-quickstart.md](integration-from-quickstart.md) after the Studio quickstart source is inspected
+- use the official current ConvoAI docs to verify the exact start flow
+- then continue with the appropriate backend/client reference:
+  - [server-sdks.md](server-sdks.md)
+  - [python-sdk.md](python-sdk.md)
+  - [go-sdk.md](go-sdk.md)
+  - [agent-samples.md](agent-samples.md)