India Agentic AI Open Hackathon Technical Guide

mkdir nvidia-ai-starter
cd nvidia-ai-starter
python3 -m venv .venv
source .venv/bin/activate

pip install -U openai python-dotenv pandas rich

cat > .env.example <<'EOF'
NVIDIA_API_KEY=nvapi-your-key
NIM_BASE_URL=https://integrate.api.nvidia.com/v1
NIM_MODEL=nvidia/nemotron-3-nano-30b-a3b
EOF

cp .env.example .env
echo ".env" >> .gitignore

# scripts/nim_chat_smoke_test.py
import os
from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()

client = OpenAI(
    base_url=os.getenv("NIM_BASE_URL", "https://integrate.api.nvidia.com/v1"),
    api_key=os.getenv("NVIDIA_API_KEY", "not-used"),
)

model = os.getenv("NIM_MODEL", "nvidia/nemotron-3-nano-30b-a3b")

response = client.chat.completions.create(
    model=model,
    messages=[
        {"role": "system", "content": "You are a concise technical mentor for hackathon teams."},
        {"role": "user", "content": "Suggest a Track A architecture for invoice processing."},
    ],
    temperature=0.2,
    max_tokens=600,
)

print(response.choices[0].message.content)

stream = client.chat.completions.create(
    model=model,
    messages=[{"role": "user", "content": "Create a demo script for a multilingual support agent."}],
    stream=True,
    temperature=0.3,
    max_tokens=700,
)

for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
print()

# Fast concise mode
resp = client.chat.completions.create(
    model=model,
    messages=[{"role": "user", "content": "Draft a simple grievance-routing agent architecture."}],
    temperature=0,
    max_tokens=700,
    extra_body={
        "chat_template_kwargs": {
            "enable_thinking": False
        }
    },
)
print(resp.choices[0].message.content)

# Deeper planning mode
resp = client.chat.completions.create(
    model=model,
    messages=[{"role": "user", "content": "Compare three architectures for a public-services assistant and choose one."}],
    temperature=0,
    max_tokens=1800,
    extra_body={
        "chat_template_kwargs": {
            "enable_thinking": True
        }
    },
)
print(resp.choices[0].message.content)

import json

tools = [{
    "type": "function",
    "function": {
        "name": "lookup_policy",
        "description": "Look up a company policy by topic.",
        "parameters": {
            "type": "object",
            "properties": {
                "topic": {"type": "string", "description": "Policy topic, for example travel or reimbursement"}
            },
            "required": ["topic"],
        },
    },
}]

def lookup_policy(topic: str) -> str:
    policies = {
        "travel": "Flights require manager approval. Hotels must be under the city cap.",
        "reimbursement": "Submit receipts within 30 days with project code and GST details.",
    }
    return policies.get(topic.lower(), "No policy found for that topic.")

messages = [{"role": "user", "content": "Can I expense a hotel for my Bangalore workshop trip?"}]

first = client.chat.completions.create(
    model=model,
    messages=messages,
    tools=tools,
    tool_choice="auto",
    temperature=0,
)

assistant_message = first.choices[0].message
messages.append(assistant_message)

if assistant_message.tool_calls:
    for call in assistant_message.tool_calls:
        args = json.loads(call.function.arguments)
        result = lookup_policy(**args)
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": result,
        })

    final = client.chat.completions.create(model=model, messages=messages, temperature=0.2)
    print(final.choices[0].message.content)

# Log in to NGC before pulling private/entitled containers.
docker login nvcr.io -u '$oauthtoken' -p "$NGC_API_KEY"

# Example pattern. Confirm the exact container path from the model page or NIM docs.
docker run --rm -it --gpus all \
  -e NGC_API_KEY="$NGC_API_KEY" \
  -v "$HOME/.cache/nim:/opt/nim/.cache" \
  -p 8000:8000 \
  nvcr.io/nim/nvidia/nemotron-3-nano-30b-a3b:latest

curl http://localhost:8000/v1/models

curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "nvidia/nemotron-3-nano-30b-a3b",
    "messages": [{"role": "user", "content": "Say hello from local NIM."}],
    "max_tokens": 64
  }'

export LOCAL_NIM_CACHE="$HOME/.cache/nim"
mkdir -p "$LOCAL_NIM_CACHE"

export NIM_LLM_IMAGE="nvcr.io/nim/nvidia/model-free-nim:latest"
export NIM_MODEL_PATH="hf://meta-llama/Llama-3.1-8B-Instruct"

docker run --gpus all \
  -e NIM_MODEL_PATH="$NIM_MODEL_PATH" \
  -e HF_TOKEN="$HF_TOKEN" \
  -v "$LOCAL_NIM_CACHE:/opt/nim/.cache" \
  -p 8000:8000 \
  "$NIM_LLM_IMAGE"

User / UI / API
  -> NeMo Agent Toolkit workflow
  -> Nemotron via NIM for reasoning
  -> Tools:
       - search / RAG
       - databases
       - business APIs
       - document parsers
       - calculators / validators
  -> Optional MCP server/client boundary
  -> Optional A2A specialist agent delegation
  -> Trace, evaluation, final answer

mkdir track-a-agent
cd track-a-agent
python3 -m venv .venv
source .venv/bin/activate

pip install -U uv
uv pip install "nvidia-nat[langchain,mcp,a2a,eval]"

export NVIDIA_API_KEY=nvapi-your-key
nat --help
nat info components -t function

# configs/invoice_agent.yml
llms:
  nim_llm:
    _type: nim
    model_name: nvidia/nemotron-3-nano-30b-a3b
    api_key: ${NVIDIA_API_KEY}
    base_url: ${NIM_BASE_URL:-https://integrate.api.nvidia.com/v1}
    temperature: 0.0
    max_tokens: 1024

functions:
  current_datetime:
    _type: current_datetime

  wikipedia_search:
    _type: wiki_search
    max_results: 3

  code_generator:
    _type: code_generation
    programming_language: Python
    llm_name: nim_llm
    description: "Generate Python helper code only when a code artifact is required."

workflow:
  _type: react_agent
  llm_name: nim_llm
  tool_names:
    - current_datetime
    - wikipedia_search
    - code_generator
  verbose: true
  parse_agent_response_max_retries: 2

# Run once from CLI.
nat run --config_file configs/invoice_agent.yml \
  --input "Design an enterprise invoice triage workflow and list the tools it needs."

# Serve as an HTTP API.
nat serve --config_file configs/invoice_agent.yml --host 0.0.0.0 --port 8000

# Call it from another terminal.
curl -X POST http://localhost:8000/generate \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [
      {"role": "user", "content": "Check this invoice workflow for missing approval steps."}
    ]
  }'

# Publish functions from the workflow as MCP tools.
nat mcp serve --config_file configs/invoice_agent.yml --host 0.0.0.0 --port 9901

# Common smoke test: list tools from an MCP-capable client, then call one tool.
# Keep network and credential policies explicit if connecting enterprise systems.

# configs/agent_with_mcp.yml
function_groups:
  mcp_public_data:
    _type: mcp_client
    server:
      transport: streamable-http
      url: "http://localhost:9901/mcp"
    include:
      - search_schemes
      - get_state_policy
    tool_call_timeout: 30
    reconnect_enabled: true
    tool_overrides:
      get_state_policy:
        alias: india_state_policy_lookup
        description: "Look up Indian state-level policy and program data."

workflow:
  _type: react_agent
  llm_name: nim_llm
  tool_names:
    - mcp_public_data

nat serve --config_file configs/agent_with_mcp.yml --port 8000
curl -s http://localhost:8000/mcp/client/tool/list | jq

uv pip install "nvidia-nat[a2a]"

nat a2a serve \
  --config_file configs/invoice_agent.yml \
  --host 0.0.0.0 \
  --port 10000

# From another terminal or another agent environment:
nat a2a client discover --url http://localhost:10000
nat a2a client get_skills --url http://localhost:10000
nat a2a client call \
  --url http://localhost:10000 \
  --message "Summarize incorporation steps for a DPIIT-recognized startup."

[
  {
    "input": "Invoice INV-102 has no PO number. What should happen?",
    "expected": "Flag for manual review or route to exception approval."
  },
  {
    "input": "Vendor is approved and amount is below threshold. What next?",
    "expected": "Proceed to payment queue after validation."
  }
]

# configs/eval_invoice_agent.yml
eval:
  general:
    output_dir: .tmp/eval_results
    dataset:
      _type: json
      file_path: data/eval/invoice_eval.json
  evaluators:
    accuracy:
      _type: ragas
      metric: AnswerAccuracy
      llm_name: nim_llm

nat eval --config_file configs/eval_invoice_agent.yml

general:
  telemetry:
    tracing:
      console:
        _type: console
        enabled: true
      phoenix:
        _type: phoenix
        endpoint: http://localhost:6006
        enabled: ${PHOENIX_ENABLED:-false}

# Quickstart pattern from the current NemoClaw docs.
curl -fsSL https://www.nvidia.com/nemoclaw.sh | bash
source ~/.bashrc

# Create or connect to a sandboxed assistant.
nemoclaw hackathon-agent connect

# Check status and logs.
nemoclaw hackathon-agent status
nemoclaw hackathon-agent logs --follow

# Confirm exact container tag from current Megatron-Bridge docs for your model.
docker run --rm -it \
  --gpus all \
  --shm-size=64g \
  -w /opt/Megatron-Bridge \
  -v "$PWD:/workspace" \
  nvcr.io/nvidia/nemo:25.11.nemotron_3_nano \
  bash

export HF_TOKEN=hf-your-token
export HF_MODEL_ID=nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16
export MEGATRON_MODEL_PATH=/workspace/checkpoints/nemotron3-nano-megatron
export HF_EXPORT_PATH=/workspace/exports/nemotron3-nano-adapted

python examples/conversion/convert_checkpoints.py import \
  --hf-model "$HF_MODEL_ID" \
  --megatron-path "$MEGATRON_MODEL_PATH" \
  --trust-remote-code

# Keep first hackathon runs small. Increase steps only after a smoke test succeeds.
torchrun --nproc-per-node=8 examples/models/nemotron_3/finetune_nemotron_3_nano.py \
  --peft lora \
  train.global_batch_size=128 \
  train.train_iters=100 \
  scheduler.lr_warmup_iters=10 \
  checkpoint.pretrained_checkpoint="$MEGATRON_MODEL_PATH" \
  checkpoint.save=/workspace/checkpoints/nemotron3-nano-lora

python examples/peft/merge_lora.py \
  --hf-model-path "$HF_MODEL_ID" \
  --lora-checkpoint /workspace/checkpoints/nemotron3-nano-lora/iter_0000100 \
  --output /workspace/exports/nemotron3-nano-lora-merged

python examples/conversion/convert_checkpoints.py export \
  --hf-model "$HF_MODEL_ID" \
  --megatron-path /workspace/checkpoints/nemotron3-nano-lora/iter_0000100 \
  --hf-path "$HF_EXPORT_PATH"

{"messages":[{"role":"system","content":"You are a careful finance-domain assistant."},{"role":"user","content":"Explain working capital in simple terms."},{"role":"assistant","content":"Working capital is current assets minus current liabilities..."}],"metadata":{"domain":"finance","source":"curated","license":"internal-approved"}}
{"messages":[{"role":"system","content":"You are a careful finance-domain assistant."},{"role":"user","content":"What is the risk of negative cash conversion cycle?"},{"role":"assistant","content":"A negative cash conversion cycle can be healthy when supplier terms fund inventory..."}],"metadata":{"domain":"finance","source":"synthetic-reviewed","license":"internal-approved"}}

git clone https://github.com/NVIDIA-NeMo/RL.git nemo-rl --recursive
cd nemo-rl
git config submodule.recurse true

pip install -U uv
uv venv
source .venv/bin/activate

export HF_HOME=/workspace/hf_cache
export HF_TOKEN=hf-your-token

# configs/grpo_domain.yaml
grpo:
  num_prompts_per_step: 32
  num_generations_per_prompt: 4
  max_num_steps: 200
  val_period: 10
  normalize_rewards: true

loss_fn:
  reference_policy_kl_penalty: 0.01
  ratio_clip_min: 0.2
  ratio_clip_max: 0.28

policy:
  model_name: /workspace/exports/nemotron3-nano-adapted
  train_global_batch_size: 128
  train_micro_batch_size: 1
  precision: bfloat16
  generation:
    backend: vllm
    temperature: 1.0

data:
  train:
    data_path: /workspace/data/train.jsonl
  validation:
    data_path: /workspace/data/val.jsonl

logger:
  log_dir: logs
  tensorboard_enabled: true
  wandb_enabled: false

cluster:
  gpus_per_node: 8
  num_nodes: 1

uv run python examples/run_grpo.py --config configs/grpo_domain.yaml

tensorboard --logdir=./logs --port=6006

import re
import torch
import ray
from nemo_rl.environments.interfaces import EnvironmentInterface, EnvironmentReturn

@ray.remote(max_restarts=-1, max_task_retries=-1)
class IndiaPolicyRewardEnv(EnvironmentInterface):
    def __init__(self, cfg):
        self.required_terms = cfg.get("required_terms", [])

    def step(self, message_log_batch, metadata):
        responses = [
            "".join(str(m["content"]) for m in conv if m["role"] == "assistant")
            for conv in message_log_batch
        ]

        scores = []
        for text, meta in zip(responses, metadata):
            grounded = float(any(t.lower() in text.lower() for t in self.required_terms))
            no_fake_section = float(
                not re.search(r"Section\s+\d+[A-Z]?", text)
                or meta.get("allow_sections", False)
            )
            lang_ok = float(meta.get("target_lang", "en") in ["en", "hi", "ta", "te"] or len(text) > 0)
            scores.append([grounded, no_fake_section, lang_ok])

        return EnvironmentReturn(
            observations=[{"role": "environment", "content": ""} for _ in responses],
            metadata=metadata,
            next_stop_strings=[None] * len(responses),
            rewards=torch.tensor(scores, dtype=torch.float32),
            terminateds=torch.ones(len(responses)),
            answers=None,
        )

{"context":[{"role":"user","content":"Explain DigiLocker KYC limits."}],"completions":[{"rank":0,"completion":[{"role":"assistant","content":"A careful answer with caveats and no unsupported legal claim."}]},{"rank":1,"completion":[{"role":"assistant","content":"An overconfident answer with made-up section numbers."}]}],"task_name":"india_policy"}

# DPO pattern. Confirm exact example paths in your checked-out NeMo RL version.
uv run python examples/run_dpo.py --config examples/configs/dpo.yaml \
  policy.model_name=./exports/india_hf \
  dpo.sft_loss_weight=0.1

# Reward model pattern.
uv run python examples/run_rm.py --config examples/configs/rm.yaml \
  policy.model_name=./exports/india_hf

Data objective
  -> Schema and sampling plan
  -> Nemotron generation through hosted NIM, local NIM, or vLLM
  -> Deterministic validators
  -> LLM-as-judge scoring
  -> NeMo Curator filtering and deduplication
  -> JSONL / Parquet export
  -> Quality report and examples

mkdir track-c-sdg
cd track-c-sdg
python3 -m venv .venv
source .venv/bin/activate

pip install -U openai python-dotenv pandas pyarrow pydantic rich
pip install -U data-designer

export NVIDIA_API_KEY=nvapi-your-key
export NIM_BASE_URL=https://integrate.api.nvidia.com/v1

import data_designer.config as dd
from data_designer.interface import DataDesigner

model_configs = [
    dd.ModelConfig(
        provider="default/nvidia-build",
        model="nvidia/nemotron-3-nano-30b-a3b",
        alias="nemotron",
    )
]

builder = dd.DataDesignerConfigBuilder(model_configs=model_configs)

builder.add_column(dd.SamplerColumnConfig(
    name="sdg_domain",
    sampler_type=dd.SamplerType.CATEGORY,
    params=dd.CategorySamplerParams(
        values=[
            "agriculture advisory",
            "maternal health navigation",
            "disaster relief coordination",
            "skills and employment guidance",
            "citizen service navigation",
        ],
        weights=[0.25, 0.20, 0.20, 0.20, 0.15],
    ),
))

builder.add_column(dd.SamplerColumnConfig(
    name="language",
    sampler_type=dd.SamplerType.CATEGORY,
    params=dd.CategorySamplerParams(
        values=["Hindi", "English", "Tamil", "Telugu", "Bengali", "Marathi", "Kannada"],
    ),
))

builder.add_column(dd.SamplerColumnConfig(
    name="user_profile",
    sampler_type=dd.SamplerType.CATEGORY,
    params=dd.CategorySamplerParams(
        values=[
            "rural first-time smartphone user",
            "urban student",
            "field health worker",
            "small business owner",
            "district officer",
        ],
    ),
))

builder.add_column(dd.LLMTextColumnConfig(
    name="user_request",
    model_alias="nemotron",
    prompt="""
Create one realistic user request for an India SDG assistant.

Domain: {{ sdg_domain }}
Language: {{ language }}
User profile: {{ user_profile }}

Requirements:
- Use natural phrasing for the selected language.
- Include concrete local constraints.
- Do not include personally identifiable information.
- Make the request useful for training an agent, not a generic chatbot.
""",
))

agent_trace_schema = {
    "type": "object",
    "properties": {
        "intent": {"type": "string"},
        "constraints": {"type": "array", "items": {"type": "string"}},
        "plan": {"type": "array", "items": {"type": "string"}},
        "tool_calls": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "tool_name": {"type": "string"},
                    "arguments": {"type": "object"},
                    "expected_observation": {"type": "string"},
                },
                "required": ["tool_name", "arguments", "expected_observation"],
            },
        },
        "risk_flags": {"type": "array", "items": {"type": "string"}},
    },
    "required": ["intent", "constraints", "plan", "tool_calls", "risk_flags"],
}

builder.add_column(dd.LLMStructuredColumnConfig(
    name="agent_trace",
    model_alias="nemotron",
    prompt="""
Given the user request below, create a structured agent execution trace.

User request:
{{ user_request }}

The trace should show how a responsible agent would use tools, constraints,
risks, and next steps for the selected India SDG domain.
""",
    schema=agent_trace_schema,
))

def validate_trace(row):
    trace = row["agent_trace"]
    if not trace.get("plan"):
        return False
    if "medical diagnosis" in str(trace).lower():
        return False
    if len(trace.get("tool_calls", [])) > 4:
        return False
    return True

builder.add_column(dd.ValidationColumnConfig(
    name="trace_valid",
    validator_type=dd.ValidatorType.PYTHON,
    params={"function": validate_trace},
    required_columns=["agent_trace"],
))

builder.add_column(dd.LLMJudgeColumnConfig(
    name="quality_judge",
    model_alias="nemotron",
    prompt="""
Evaluate this synthetic agent training record.

Domain: {{ sdg_domain }}
Language: {{ language }}
User: {{ user_request }}
Trace: {{ agent_trace }}

Score strictly. Penalize unsafe advice, vague plans, invalid tool use,
poor local relevance, and language mismatch.
""",
    scores=[
        dd.Score(name="local_relevance", description="Does this fit the Indian SDG context?", options={1: "poor", 3: "acceptable", 5: "excellent"}),
        dd.Score(name="tool_use_quality", description="Are tool calls plausible and useful?", options={1: "bad", 3: "usable", 5: "strong"}),
        dd.Score(name="safety", description="Does it avoid harmful or overconfident guidance?", options={1: "unsafe", 3: "minor issues", 5: "safe"}),
        dd.Score(name="language_quality", description="Is the selected language fluent and natural?", options={1: "poor", 3: "okay", 5: "native-like"}),
    ],
))

data_designer = DataDesigner()

data_designer.validate(builder)

preview = data_designer.preview(config_builder=builder, num_records=5)
preview.display_sample_record(index=0)

results = data_designer.create(
    config_builder=builder,
    num_records=500,
    dataset_name="india-sdg-agentic-synthetic-v1",
)

df = results.load_dataset()

# notebooks/sdg_multilingual_support.py
import os
import json
import random
from openai import OpenAI
from pydantic import BaseModel, Field

client = OpenAI(
    base_url=os.getenv("NIM_BASE_URL", "https://integrate.api.nvidia.com/v1"),
    api_key=os.environ["NVIDIA_API_KEY"],
)
MODEL = "nvidia/nemotron-3-nano-30b-a3b"

class ConversationMeta(BaseModel):
    language: str
    domain: str
    intent: str
    difficulty: str
    safety_risk: str = Field(description="none, low, medium, high")

LANGUAGES = ["Hindi", "English", "Tamil", "Telugu", "Bengali", "Marathi"]
DOMAINS = ["banking", "healthcare", "telecom", "travel", "education"]
INTENTS = ["complaint", "question", "refund", "troubleshooting", "appointment"]

def sample_seed():
    return {
        "language": random.choice(LANGUAGES),
        "domain": random.choice(DOMAINS),
        "intent": random.choice(INTENTS),
        "difficulty": random.choice(["easy", "medium", "hard"]),
    }

def generate_conversation(seed):
    prompt = f"""
Create a realistic multilingual customer support conversation.
Language: {seed["language"]}
Domain: {seed["domain"]}
Intent: {seed["intent"]}
Difficulty: {seed["difficulty"]}

Return exactly 6 to 10 turns as JSON:
{{"messages":[{{"role":"user","content":"..."}},{{"role":"assistant","content":"..."}}]}}
"""
    response = client.chat.completions.create(
        model=MODEL,
        messages=[{"role": "user", "content": prompt}],
        temperature=0.7,
        max_tokens=1200,
        response_format={"type": "json_object"},
    )
    return json.loads(response.choices[0].message.content)

def judge_record(seed, conversation):
    rubric = f"""
Score this synthetic conversation from 1 to 5 on:
1. language_quality
2. domain_relevance
3. assistant_helpfulness
4. safety

Return JSON with integer scores and a short reason.
Seed: {json.dumps(seed)}
Conversation: {json.dumps(conversation, ensure_ascii=False)}
"""
    response = client.chat.completions.create(
        model=MODEL,
        messages=[{"role": "user", "content": rubric}],
        temperature=0,
        max_tokens=600,
        response_format={"type": "json_object"},
    )
    return json.loads(response.choices[0].message.content)

records = []
for i in range(20):
    seed = sample_seed()
    conversation = generate_conversation(seed)
    scores = judge_record(seed, conversation)
    records.append({"id": i, "seed": seed, "conversation": conversation, "scores": scores})

with open("synthetic_support_conversations.jsonl", "w", encoding="utf-8") as f:
    for record in records:
        f.write(json.dumps(record, ensure_ascii=False) + "\n")

def has_min_turns(record, min_turns=6):
    return len(record["conversation"].get("messages", [])) >= min_turns

def alternates_roles(record):
    roles = [m.get("role") for m in record["conversation"].get("messages", [])]
    return all(role in {"user", "assistant"} for role in roles)

def score_value(record, key, threshold=3):
    value = record.get("scores", {}).get(key)
    if isinstance(value, dict):
        value = value.get("score")
    try:
        return int(value) >= threshold
    except Exception:
        return False

def keep(record):
    return (
        has_min_turns(record)
        and alternates_roles(record)
        and score_value(record, "language_quality")
        and score_value(record, "domain_relevance")
        and score_value(record, "assistant_helpfulness")
        and score_value(record, "safety")
    )

filtered = [r for r in records if keep(r)]
print(f"Kept {len(filtered)} / {len(records)} records")

with open("support_sft.jsonl", "w", encoding="utf-8") as f:
    for record in filtered:
        out = {
            "messages": [
                {"role": "system", "content": "You are a helpful multilingual customer support assistant."},
                *record["conversation"]["messages"],
            ],
            "metadata": {
                **record["seed"],
                "scores": record["scores"],
                "source": "synthetic-nemotron",
            },
        }
        f.write(json.dumps(out, ensure_ascii=False) + "\n")

# Choose extras based on your environment and CUDA version.
pip install -U nemo-curator

# For GPU-accelerated text curation on CUDA 12 environments, confirm the latest extra name in docs:
pip install --extra-index-url https://pypi.nvidia.com "nemo-curator[text_cuda12]"

import json
import pandas as pd

rows = []
with open("support_sft.jsonl", encoding="utf-8") as f:
    for idx, line in enumerate(f):
        item = json.loads(line)
        text = "\n".join(m["content"] for m in item["messages"])
        rows.append({"id": idx, "text": text, "metadata": item.get("metadata", {})})

df = pd.DataFrame(rows)
df.to_parquet("support_sft_for_curator.parquet", index=False)

# API names can vary across Curator releases. Use this as an implementation sketch.
from nemo_curator.pipeline import Pipeline
from nemo_curator.stages.text.io.reader.parquet import ParquetReader
from nemo_curator.stages.text.io.writer.parquet import ParquetWriter
from nemo_curator.stages.text.modules.score_filter import Filter

pipeline = Pipeline(name="support_sft_cleanup")
pipeline.add_stage(ParquetReader(file_paths="support_sft_for_curator.parquet"))

# Drop very short records.
pipeline.add_stage(
    Filter(
        filter_fn=lambda text: len(text) >= 400,
        filter_field="text",
    )
)

# Add exact/fuzzy/semantic deduplication stages based on your installed Curator version.

pipeline.add_stage(ParquetWriter(path="curated_support_sft.parquet"))

# Synthetic Dataset Quality Report

Dataset: support_sft.jsonl
Generator model: nvidia/nemotron-3-nano-30b-a3b
Records generated: 2,000
Records kept after validation: 1,420
Duplicate removal: exact + fuzzy
Languages: Hindi, English, Tamil, Telugu, Bengali, Marathi
Average LLM judge score: 4.1 / 5

Known limitations:
- Synthetic conversations still need human spot checks.
- Domain policies are examples, not legal or medical advice.
- Low-resource language quality should be reviewed by native speakers.

# Demo Script

1. Problem
   - Who has this problem?
   - What is painful today?

2. NVIDIA stack
   - Model:
   - Runtime:
   - NeMo tools:
   - Data/training path:

3. Live demo path
   - Input:
   - Intermediate tool/model/data step:
   - Output:

4. Evaluation
   - Metric:
   - Baseline:
   - Result:

5. Next step
   - What would productionize this?