# Use Cases

NCN Network v2 enables various decentralized AI applications. This page covers common use cases and implementation patterns.

***

## AI Inference as a Service

### Overview

Deploy AI models and offer inference as a pay-per-use service.

```
┌──────────┐     ┌──────────────┐     ┌───────────────┐
│  Client  │────▶│   Gateway    │────▶│ Compute Node  │
│  (App)   │     │  (Your Org)  │     │  (GPU Farm)   │
└──────────┘     └──────────────┘     └───────────────┘
      │                                       │
      └───────────── Payment ─────────────────┘
```

### Benefits

* **No infrastructure management**: Use existing compute providers
* **Pay only for usage**: No idle GPU costs
* **Scalable**: Add more compute nodes as demand grows
* **Transparent pricing**: On-chain payment records

### Implementation

1. **Gateway Operator**: Create a subnet with your models
2. **Compute Providers**: Join your subnet, provide GPU resources
3. **Clients**: Send inference requests, pay per request

### Example: Image Classification Service

```python
# Client code
import requests

response = requests.post(
    "https://your-gateway.com/api/v1/inference",
    json={
        "model_uuid": "resnet50",
        "input_data": {"image_url": "https://example.com/image.jpg"}
    },
    headers={"Authorization": "Bearer YOUR_TOKEN"}
)

result = response.json()
print(f"Classification: {result['output_data']}")
```

***

## Decentralized Model Hosting

### Overview

Host AI models in a decentralized network where multiple compute providers can serve requests.

### Architecture

```
                    ┌────────────────┐
                    │    Subnet      │
                    │  (Model Set)   │
                    └───────┬────────┘
                            │
        ┌───────────────────┼───────────────────┐
        │                   │                   │
┌───────▼───────┐   ┌───────▼───────┐   ┌───────▼───────┐
│  Compute 1    │   │  Compute 2    │   │  Compute 3    │
│  (Provider A) │   │  (Provider B) │   │  (Provider C) │
└───────────────┘   └───────────────┘   └───────────────┘
```

### Benefits

* **Redundancy**: Multiple providers serve requests
* **Geographic distribution**: Low latency worldwide
* **Censorship resistance**: No single point of control
* **Competition**: Providers compete on price and quality

### Setup

1. **Create Subnet**:

   ```bash
   subnet-cli create -c model_config.json
   ```
2. **Providers Join**:

   ```bash
   compute_node --subnet-id 1 --sync-models
   ```
3. **Clients Connect**:

   ```bash
   # Requests automatically routed to available providers
   ```

***

## Text-to-Audio Pipeline (Bark)

### Overview

NCN Network supports the Bark text-to-audio model with distributed pipeline execution.

### Pipeline Stages

```
Input Text → Semantic → Coarse → Fine → Audio Output
              Stage      Stage    Stage
```

### Implementation

The Bark pipeline uses three specialized models:

| Stage    | Model                    | Purpose                            |
| -------- | ------------------------ | ---------------------------------- |
| Semantic | `bark_semantic_model.pt` | Text to semantic tokens            |
| Coarse   | `bark_coarse_model.pt`   | Semantic to coarse acoustic tokens |
| Fine     | `bark_fine_model.pt`     | Coarse to fine acoustic tokens     |

### Subnet Configuration

```json
{
  "gateway_address": "0xYourGateway",
  "models": [
    {
      "name": "bark_semantic",
      "download_url": "https://huggingface.co/suno/bark/resolve/main/...",
      "executor_script": "semantic_model_executor.py"
    },
    {
      "name": "bark_coarse",
      "download_url": "https://huggingface.co/suno/bark/resolve/main/...",
      "executor_script": "coarse_model_executor.py"
    },
    {
      "name": "bark_fine",
      "download_url": "https://huggingface.co/suno/bark/resolve/main/...",
      "executor_script": "fine_model_executor.py"
    }
  ]
}
```

### Client Usage

```python
# Run Bark pipeline
text = "Hello, this is a test of the NCN Network text-to-speech system."

# Stage 1: Semantic
semantic_tokens = client.inference("bark_semantic", {"text": text})

# Stage 2: Coarse
coarse_tokens = client.inference("bark_coarse", {"semantic_tokens": semantic_tokens})

# Stage 3: Fine
audio_data = client.inference("bark_fine", {"coarse_tokens": coarse_tokens})

# Save audio
with open("output.wav", "wb") as f:
    f.write(audio_data)
```

***

## Custom Model Deployment

### Overview

Deploy your own trained models on the NCN Network.

### Requirements

1. **Model Format**: TorchScript (`.pt`), ONNX (`.onnx`), or Safetensors
2. **Executor Script**: Python script for inference
3. **Input/Output Schema**: JSON format definition

### Step-by-Step

#### 1. Export Your Model

```python
import torch

# Your trained model
model = MyModel()
model.load_state_dict(torch.load("model_weights.pth"))
model.eval()

# Export to TorchScript
scripted = torch.jit.script(model)
scripted.save("my_model.pt")
```

#### 2. Create Executor Script

```python
# my_model_executor.py
import os
import json
import torch

def main():
    # Load input
    input_file = os.environ.get("INPUT_FILE")
    with open(input_file) as f:
        input_data = json.load(f)
    
    # Load model
    model = torch.jit.load("my_model.pt")
    
    # Run inference
    input_tensor = torch.tensor(input_data["input"])
    output = model(input_tensor)
    
    # Write output
    output_file = os.environ.get("OUTPUT_FILE")
    with open(output_file, "w") as f:
        json.dump({"output": output.tolist()}, f)

if __name__ == "__main__":
    main()
```

#### 3. Configure Subnet

```json
{
  "models": [
    {
      "name": "my_model",
      "download_url": "https://your-storage.com/my_model.pt",
      "executor_script": "base64_encoded_executor_script",
      "file_size_bytes": 500000000
    }
  ]
}
```

#### 4. Deploy

```bash
subnet-cli create -c my_model_config.json
```

***

## Batch Processing

### Overview

Process large batches of inference requests efficiently.

### Architecture

```
┌─────────────────────────────────────────────────────────┐
│                    Batch Job                             │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐    │
│  │ Request │  │ Request │  │ Request │  │ Request │ ...│
│  │    1    │  │    2    │  │    3    │  │    N    │    │
│  └────┬────┘  └────┬────┘  └────┬────┘  └────┬────┘    │
└───────┼────────────┼────────────┼────────────┼──────────┘
        │            │            │            │
        ▼            ▼            ▼            ▼
    ┌───────────────────────────────────────────────┐
    │              Load Balancer                     │
    │         (Gateway Distribution)                 │
    └───────────────────────────────────────────────┘
        │            │            │            │
        ▼            ▼            ▼            ▼
    ┌────────┐  ┌────────┐  ┌────────┐  ┌────────┐
    │Compute1│  │Compute2│  │Compute3│  │Compute4│
    └────────┘  └────────┘  └────────┘  └────────┘
```

### Implementation

```python
import asyncio
from ncn_client import NCNClient

async def process_batch(items):
    client = NCNClient("https://gateway.example.com")
    
    # Submit all requests concurrently
    tasks = [
        client.inference_async("model_name", item)
        for item in items
    ]
    
    # Wait for all results
    results = await asyncio.gather(*tasks)
    return results

# Process 1000 items
batch = load_batch_data()
results = asyncio.run(process_batch(batch))
```

***

## Real-Time Applications

### Overview

Build real-time AI applications with WebSocket streaming.

### WebSocket Connection

```javascript
const ws = new WebSocket("wss://gateway.example.com/ws");

ws.onopen = () => {
    // Subscribe to task updates
    ws.send(JSON.stringify({
        type: "subscribe",
        request_id: "my-request-123"
    }));
};

ws.onmessage = (event) => {
    const data = JSON.parse(event.data);
    
    if (data.type === "task_status") {
        console.log(`Status: ${data.status}`);
    } else if (data.type === "task_result") {
        console.log(`Result: ${data.output_data}`);
    }
};
```

### Use Cases

* Live transcription
* Real-time translation
* Interactive chatbots
* Voice assistants

***

## Next Steps

* [Getting Started](/nc/neurochainai-guides/introduction/getting-started.md) - Set up your environment
* [Key Concepts](/nc/neurochainai-guides/introduction/key-concepts.md) - Understand the system
* [Client Integration](/nc/neurochainai-guides/clients/clients.md) - Build your client


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.neurochain.ai/nc/neurochainai-guides/introduction/use-cases.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.