docs: add guides to docs (#243)

Co-authored-by: Meenakshi Sharma <163925564+nvda-mesharma@users.noreply.github.com>

docs/guides/dynamo_sdk.md

+# Dynamo SDK
+
+Dynamo is a python based SDK for building and deploying distributed inference applications. Dynamo leverages concepts from open source projects like [BentoML](https://github.com/bentoml/bentoml) to provide a developer friendly experience to go from local development to K8s deployment.
+
+## Installation
+
+```bash
+pip install ai-dynamo
+```
+
+## Quickstart
+Lets build a simple distributed pipeline with 3 components: `Frontend`, `Middle` and `Backend`. The structure of the pipeline looks like this:
+
+```
+Users/Clients (HTTP)
+      │
+      ▼
+┌─────────────┐
+│  Frontend   │  HTTP API endpoint (/generate)
+└─────────────┘
+      │
+      ▼
+┌─────────────┐
+│   Middle    │
+└─────────────┘
+      │
+      ▼
+┌─────────────┐
+│  Backend    │
+└─────────────┘
+```
+
+The code for the pipeline looks like this:
+
+```python
+# filename: pipeline.py
+
+from dynamo.sdk import service, dynamo_endpoint, depends, api
+from pydantic import BaseModel
+
+class RequestType(BaseModel):
+    text: str
+
+@service(resources={"cpu": "1"})
+class Frontend:
+    middle = depends(Middle)
+
+    @api
+    async def generate(self, text: str):
+        request = RequestType(text=text)
+        async for response in self.middle.generate(request.model_dump_json()):
+            yield f"Frontend: {response}"
+
+@service(
+    resources={"cpu": "1"},
+    dynamo={"enabled": True, "namespace": "inference"}
+)
+class Middle:
+    backend = depends(Backend)
+
+    @dynamo_endpoint()
+    async def generate(self, req: RequestType):
+        text = f"{req.text}-mid"
+        for token in text.split():
+            yield f"Mid: {token}"
+
+@service(
+    resources={"cpu": "1"},
+    dynamo={"enabled": True, "namespace": "inference"}
+)
+class Backend:
+    @dynamo_endpoint()
+    async def generate(self, req: RequestType):
+        text = f"{req.text}-back"
+        for token in text.split():
+            yield f"Backend: {token}"
+```
+
+You can run this pipeline locally by spinning up ETCD and NATS and then running the pipeline:
+
+```bash
+# Spin up ETCD and NATS
+docker compose -f deploy/docker-compose.yml up -d
+```
+
+then
+
+```bash
+# Run the pipeline
+dynamo serve pipeline:Frontend
+```
+
+Once it's up and running, you can make a request to the pipeline using
+
+```bash
+curl -X POST http://localhost:3000/generate \
+    -H "Content-Type: application/json" \
+    -d '{"text": "federer"}'
+```
+
+You should see the following output:
+
+```bash
+federer-mid-back
+```
+
+You can find in-depth documentation for the Dynamo SDK [here](../../deploy/dynamo/sdk/docs/sdk/README.md) and the Dynamo CLI [here](../../deploy/dynamo/sdk/docs/cli/README.md)
+

docs/guides/hello_world.md

+<!--
+SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+
+## Overview
+
+Pipeline Architecture:
+
+```
+Users/Clients (HTTP)
+      │
+      ▼
+┌─────────────┐
+│  Frontend   │  HTTP API endpoint (/generate)
+└─────────────┘
+      │ dynamo/runtime
+      ▼
+┌─────────────┐
+│   Middle    │
+└─────────────┘
+      │ dynamo/runtime
+      ▼
+┌─────────────┐
+│  Backend    │
+└─────────────┘
+```
+
+
+## Unified serve
+1. Launch all three services using a single command -
+
+```bash
+cd /workspace/examples/hello_world
+dynamo serve hello_world:Frontend
+```
+
+2. Send request to frontend using curl -
+
+```bash
+curl -X 'POST' \
+  'http://localhost:3000/generate' \
+  -H 'accept: text/event-stream' \
+  -H 'Content-Type: application/json' \
+  -d '{
+  "text": "test"
+}'
+```

docs/guides/llm_deployment.md

+<!--
+SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+
+# LLM Deployment Examples
+
+This directory contains examples and reference implementations for deploying Large Language Models (LLMs) in various configurations.
+
+## Components
+
+- workers: Prefill and decode worker handles actual LLM inference
+- router: Handles API requests and routes them to appropriate workers based on specified strategy
+- frontend: OpenAI compatible http server handles incoming requests
+
+## Deployment Architectures
+
+### Aggregated
+Single-instance deployment where both prefill and decode are done by the same worker.
+
+### Disaggregated
+Distributed deployment where prefill and decode are done by separate workers that can scale independently.
+
+```mermaid
+sequenceDiagram
+    participant D as VllmWorker
+    participant Q as PrefillQueue
+    participant P as PrefillWorker
+
+    Note over D: Request is routed to decode
+    D->>D: Decide if prefill should be done locally or remotely
+
+        D->>D: Allocate KV blocks
+        D->>Q: Put RemotePrefillRequest on the queue
+
+        P->>Q: Pull request from the queue
+        P-->>D: Read cached KVs from Decode
+
+        D->>D: Decode other requests
+        P->>P: Run prefill
+        P-->>D: Write prefilled KVs into allocated blocks
+        P->>D: Send completion notification
+        Note over D: Notification received when prefill is done
+        D->>D: Schedule decoding
+```
+
+## Getting Started
+
+1. Choose a deployment architecture based on your requirements
+2. Configure the components as needed
+3. Deploy using the provided scripts
+
+### Prerequisites
+
+Start required services (etcd and NATS) using [Docker Compose](/deploy/docker-compose.yml)
+```bash
+docker compose -f deploy/docker-compose.yml up -d
+```
+
+### Build docker
+
+```
+./container/build.sh
+```
+
+### Run container
+
+```
+./container/run.sh -it
+```
+## Run Deployment
+
+This figure shows an overview of the major components to deploy:
+
+```
+                                                 +----------------+
+                                          +------| prefill worker |-------+
+                                   notify |      |                |       |
+                                 finished |      +----------------+       | pull
+                                          v                               v
++------+      +-----------+      +------------------+    push     +---------------+
+| HTTP |----->| processor |----->| decode/monolith  |------------>| prefill queue |
+|      |<-----|           |<-----|      worker      |             |               |
++------+      +-----------+      +------------------+             +---------------+
+                  |    ^                  |
+       query best |    | return           | publish kv events
+           worker |    | worker_id        v
+                  |    |         +------------------+
+                  |    +---------|     kv-router    |
+                  +------------->|                  |
+                                 +------------------+
+
+```
+
+### Example architectures
+
+#### Aggregated serving
+```bash
+cd /workspace/examples/llm
+dynamo serve graphs.agg:Frontend -f ./configs/agg.yaml
+```
+
+#### Aggregated serving with KV Routing
+```bash
+cd /workspace/examples/llm
+dynamo serve graphs.agg_router:Frontend -f ./configs/agg_router.yaml
+```
+
+#### Disaggregated serving
+```bash
+cd /workspace/examples/llm
+dynamo serve graphs.disagg:Frontend -f ./configs/disagg.yaml
+```
+
+#### Disaggregated serving with KV Routing
+```bash
+cd /workspace/examples/llm
+dynamo serve graphs.disagg_router:Frontend -f ./configs/disagg_router.yaml
+```
+
+### Client
+
+In another terminal:
+```bash
+# this test request has around 200 tokens isl
+
+curl localhost:8000/v1/chat/completions   -H "Content-Type: application/json"   -d '{
+    "model": "deepseek-ai/DeepSeek-R1-Distill-Llama-8B",
+    "messages": [
+    {
+        "role": "user",
+        "content": "In the heart of Eldoria, an ancient land of boundless magic and mysterious creatures, lies the long-forgotten city of Aeloria. Once a beacon of knowledge and power, Aeloria was buried beneath the shifting sands of time, lost to the world for centuries. You are an intrepid explorer, known for your unparalleled curiosity and courage, who has stumbled upon an ancient map hinting at ests that Aeloria holds a secret so profound that it has the potential to reshape the very fabric of reality. Your journey will take you through treacherous deserts, enchanted forests, and across perilous mountain ranges. Your Task: Character Background: Develop a detailed background for your character. Describe their motivations for seeking out Aeloria, their skills and weaknesses, and any personal connections to the ancient city or its legends. Are they driven by a quest for knowledge, a search for lost familt clue is hidden."
+    }
+    ],
+    "stream":false,
+    "max_tokens": 30
+  }'
+
+```
+
+### Close deployment
+
+Kill all dynamo processes managed by circusd.
+
+```
+function kill_tree() {
+    local parent=$1
+    local children=$(ps -o pid= --ppid $parent)
+    for child in $children; do
+        kill_tree $child
+    done
+    echo "Killing process $parent"
+    kill -9 $parent
+}
+
+# kill process-tree of circusd
+kill_tree $(pgrep circusd)
+```