English العربية Deutsch Español Français हिन्दी Italiano 日本語 한국어 Português (BR) Русский Türkçe 中文

मॉड्यूल S: सॉवरेन सेटअप

STREETS डेवलपर इनकम कोर्स — फ्री मॉड्यूल सप्ताह 1-2 | 6 पाठ | डिलीवरेबल: आपका सॉवरेन स्टैक डॉक्यूमेंट

"आपका रिग आपका बिज़नेस इंफ्रास्ट्रक्चर है। इसे उसी तरह कॉन्फ़िगर करें।"

आपके पास पहले से ही सबसे शक्तिशाली इनकम-जनरेटिंग टूल है जो ज़्यादातर लोगों के पास कभी नहीं होगा: एक डेवलपर वर्कस्टेशन जिसमें इंटरनेट कनेक्शन, लोकल कंप्यूट, और सब कुछ जोड़ने की स्किल्स हैं।

ज़्यादातर डेवलपर्स अपने रिग को एक कंज़्यूमर प्रोडक्ट की तरह ट्रीट करते हैं। कुछ जिस पर गेम खेलते हैं, कोड करते हैं, ब्राउज़ करते हैं। लेकिन वही मशीन — जो अभी आपकी डेस्क के नीचे रखी है — इंफ़रेंस चला सकती है, API सर्व कर सकती है, डेटा प्रोसेस कर सकती है, और जब आप सो रहे हों तब दिन में 24 घंटे रेवेन्यू जनरेट कर सकती है।

यह मॉड्यूल इस बारे में है कि आपके पास जो पहले से है उसे एक अलग नज़रिए से देखें। "मैं क्या बना सकता हूँ?" नहीं बल्कि "मैं क्या बेच सकता हूँ?"

इन दो हफ्तों के अंत तक, आपके पास होगा:

कोई हवा-हवाई बातें नहीं। कोई "बस अपने आप पर भरोसा रखो" नहीं। असली नंबर, असली कमांड्स, असली फ़ैसले।

चलिए शुरू करते हैं।

पाठ 1: रिग ऑडिट

"आपको 4090 की ज़रूरत नहीं है। असल में क्या मायने रखता है यह रहा।"

आपकी मशीन एक बिज़नेस एसेट है

जब कोई कंपनी अपने इंफ्रास्ट्रक्चर का मूल्यांकन करती है, तो वह सिर्फ़ स्पेक्स नहीं लिस्ट करती — वह क्षमताओं को रेवेन्यू अवसरों से मैप करती है। अभी आप यही करने वाले हैं।

टर्मिनल खोलें और नीचे दिए गए कमांड्स चलाएँ। हर नंबर लिख लें। पाठ 6 में सॉवरेन स्टैक डॉक्यूमेंट के लिए इनकी ज़रूरत होगी।

हार्डवेयर इन्वेंटरी

CPU

# Linux/Mac
lscpu | grep "Model name\|CPU(s)\|Thread(s)"
# or
cat /proc/cpuinfo | grep "model name" | head -1
nproc

# Windows (PowerShell)
Get-CimInstance -ClassName Win32_Processor | Select-Object Name, NumberOfCores, NumberOfLogicalProcessors

# macOS
sysctl -n machdep.cpu.brand_string
sysctl -n hw.ncpu

इनकम के लिए क्या मायने रखता है:

RAM

# Linux
free -h

# macOS
sysctl -n hw.memsize | awk '{print $0/1073741824 " GB"}'

# Windows (PowerShell)
(Get-CimInstance -ClassName Win32_ComputerSystem).TotalPhysicalMemory / 1GB

इनकम के लिए क्या मायने रखता है:

GPU

# NVIDIA
nvidia-smi

# Check VRAM specifically
nvidia-smi --query-gpu=name,memory.total,memory.free --format=csv

# AMD (Linux)
rocm-smi

# macOS (Apple Silicon)
system_profiler SPDisplaysDataType

इनकम के लिए क्या मायने रखता है:

यही वह स्पेक है जिस पर लोग ज़्यादा ध्यान देते हैं, और यह रही सच्चाई: आपका GPU आपका लोकल LLM टियर तय करता है, और आपका लोकल LLM टियर तय करता है कि कौन से इनकम स्ट्रीम्स सबसे तेज़ चलते हैं। लेकिन यह तय नहीं करता कि आप पैसे कमा सकते हैं या नहीं।

VRAM LLM क्षमता इनकम रेलेवेंस
0 (सिर्फ CPU) 7B मॉडल ~5 टोकन/सेकंड पर बैच प्रोसेसिंग, एसिंक वर्क। धीमा लेकिन काम करता है।
6-8 GB (RTX 3060, आदि) 7B मॉडल ~30 टोकन/सेकंड, 13B क्वांटाइज़्ड ज़्यादातर ऑटोमेशन इनकम स्ट्रीम्स के लिए काफ़ी।
12 GB (RTX 3060 12GB, 4070) 13B फुल स्पीड पर, 30B क्वांटाइज़्ड स्वीट स्पॉट। ज़्यादातर रेवेन्यू इंजन्स यहाँ अच्छे चलते हैं।
16-24 GB (RTX 4090, 3090) 30B-70B मॉडल प्रीमियम टियर। ऐसी क्वालिटी बेचें जो दूसरे लोकली मैच नहीं कर सकते।
48 GB+ (ड्यूअल GPU, A6000) 70B+ स्पीड पर एंटरप्राइज़-ग्रेड लोकल इंफ़रेंस। गंभीर प्रतिस्पर्धात्मक लाभ।
Apple Silicon 32GB+ (M2/M3 Pro/Max) 30B+ यूनिफाइड मेमोरी से बेहतरीन एफिशिएंसी। NVIDIA इक्विवेलेंट से कम पावर कॉस्ट।

कोई डेडिकेटेड GPU नहीं मिला। आप CPU पर इंफ़रेंस चलाएँगे, जिसका मतलब है ~5-12 टोकन/सेकंड 7B मॉडल पर। बैच प्रोसेसिंग और एसिंक वर्क के लिए यह ठीक है। कस्टमर-फेसिंग आउटपुट के लिए स्पीड गैप भरने के लिए API कॉल्स इस्तेमाल करें।

सीधी बात: अगर आपके पास RTX 3060 12GB है, तो आप AI को मॉनेटाइज़ करने की कोशिश कर रहे 95% डेवलपर्स से बेहतर पोज़िशन में हैं। 4090 का इंतज़ार बंद करें। RTX 3060 12GB लोकल AI की Honda Civic है — विश्वसनीय, कुशल, काम पूरा करती है। GPU अपग्रेड पर जो पैसा खर्च करेंगे वह कस्टमर-फेसिंग क्वालिटी के लिए API क्रेडिट्स पर बेहतर खर्च होगा जबकि आपके लोकल मॉडल भारी काम संभालते हैं।

स्टोरेज

# Linux/Mac
df -h

# Windows (PowerShell)
Get-PSDrive -PSProvider FileSystem | Select-Object Name, @{N='Used(GB)';E={[math]::Round($_.Used/1GB,1)}}, @{N='Free(GB)';E={[math]::Round($_.Free/1GB,1)}}

इनकम के लिए क्या मायने रखता है:

नेटवर्क

# Quick speed test (install speedtest-cli if needed)
# pip install speedtest-cli
speedtest-cli --simple

# Or just check your plan
# Upload speed matters more than download for serving

इनकम के लिए क्या मायने रखता है:

अपटाइम

यह वो स्पेक है जिसके बारे में कोई नहीं सोचता, लेकिन यह शौकियों को सोते हुए पैसे कमाने वालों से अलग करती है।

खुद से पूछें:

अगर 24/7 नहीं चला सकते, तो ठीक है — इस कोर्स में कई इनकम स्ट्रीम्स एसिंक बैच जॉब हैं जो आप मैन्युअली ट्रिगर करते हैं। लेकिन जो सच में पैसिव इनकम जनरेट करते हैं उन्हें अपटाइम चाहिए।

क्विक अपटाइम सेटअप (अगर चाहते हैं):

# Enable Wake-on-LAN (check BIOS)
# Set up SSH access
sudo systemctl enable ssh  # Linux

# Auto-restart on crash (systemd service example)
# /etc/systemd/system/my-income-worker.service
[Unit]
Description=Income Worker Process
After=network.target

[Service]
Type=simple
ExecStart=/usr/local/bin/my-worker
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

बिजली का गणित

लोग या तो इसे नज़रअंदाज़ करते हैं या इसे बहुत बड़ा बना देते हैं। चलिए असली गणित करते हैं।

अपना असल पावर ड्रॉ मापें:

# If you have a Kill-A-Watt meter or smart plug with monitoring:
# Measure at idle, at load (running inference), and at max (GPU full utilization)

# Rough estimates if you don't have a meter:
# Desktop (no GPU, idle): 60-100W
# Desktop (mid-range GPU, idle): 80-130W
# Desktop (high-end GPU, idle): 100-180W
# Desktop (GPU under inference load): add 50-80% of GPU TDP
# Laptop: 15-45W
# Mac Mini M2: 7-15W (seriously)
# Apple Silicon laptop: 10-30W

मासिक कॉस्ट कैलकुलेशन:

Monthly cost = (Watts / 1000) x Hours x Price per kWh

Example: Desktop with RTX 3060, running inference 8 hours/day, idle 16 hours/day
- Inference: (250W / 1000) x 8h x 30 days x $0.12/kWh = $7.20/month
- Idle: (100W / 1000) x 16h x 30 days x $0.12/kWh = $5.76/month
- Total: ~$13/month

Example: Same rig, 24/7 inference
- (250W / 1000) x 24h x 30 days x $0.12/kWh = $21.60/month

Example: Mac Mini M2, 24/7
- (12W / 1000) x 24h x 30 days x $0.12/kWh = $1.04/month

US में औसत बिजली लगभग $0.12/kWh है। अपनी असली रेट चेक करें — यह बहुत अलग-अलग होती है। कैलिफ़ोर्निया $0.25/kWh हो सकती है। कुछ यूरोपीय देश $0.35/kWh तक पहुँचते हैं। US मिडवेस्ट के कुछ हिस्से $0.08/kWh हैं।

मुख्य बात: इनकम के लिए अपना रिग 24/7 चलाने में बिजली का खर्च $1-$30/महीने के बीच आता है। अगर आपके इनकम स्ट्रीम्स इतना भी कवर नहीं कर सकते, तो समस्या बिजली नहीं है — इनकम स्ट्रीम है।

रेवेन्यू इंजन टाइप के अनुसार न्यूनतम स्पेक्स

यह एक प्रीव्यू है कि पूरे STREETS कोर्स में हम कहाँ जा रहे हैं। अभी, बस चेक करें कि आपका रिग कहाँ आता है:

रेवेन्यू इंजन CPU RAM GPU स्टोरेज नेटवर्क
कंटेंट ऑटोमेशन (ब्लॉग पोस्ट, न्यूज़लेटर) 4+ कोर 16 GB वैकल्पिक (API फ़ॉलबैक) 50 GB फ्री 10 Mbps अप
डेटा प्रोसेसिंग सर्विसेज़ 8+ कोर 32 GB वैकल्पिक 200 GB फ्री 50 Mbps अप
लोकल AI API सर्विसेज़ 8+ कोर 32 GB 8+ GB VRAM 100 GB फ्री 50 Mbps अप
कोड जनरेशन टूल्स 8+ कोर 16 GB 8+ GB VRAM या API 50 GB फ्री 10 Mbps अप
डॉक्यूमेंट प्रोसेसिंग 4+ कोर 16 GB वैकल्पिक 100 GB फ्री 10 Mbps अप
ऑटोनॉमस एजेंट्स 8+ कोर 32 GB 12+ GB VRAM 100 GB फ्री 50 Mbps अप

आम गलती: "मुझे शुरू करने से पहले अपना हार्डवेयर अपग्रेड करना होगा।" नहीं। जो है उससे शुरू करें। जो गैप आपका हार्डवेयर कवर नहीं कर सकता उसके लिए API कॉल्स इस्तेमाल करें। रेवेन्यू जस्टिफ़ाई करे तब अपग्रेड करें — पहले नहीं।

पाठ 1 चेकपॉइंट

अब तक आपने यह लिख लिया होना चाहिए:

ये नंबर रखें। पाठ 6 में सॉवरेन स्टैक डॉक्यूमेंट में इन्हें डालेंगे।

पूरे STREETS कोर्स में, मॉड्यूल R (रेवेन्यू इंजन्स) आपको ऊपर लिस्टेड हर इंजन टाइप के लिए विशिष्ट, स्टेप-बाई-स्टेप प्लेबुक देता है — जिसमें बिल्ड और डिप्लॉय करने का सटीक कोड शामिल है।

पाठ 2: लोकल LLM स्टैक

"Ollama को प्रोडक्शन यूज़ के लिए सेट करें — सिर्फ़ चैट के लिए नहीं।"

लोकल LLM इनकम के लिए क्यों मायने रखते हैं

हर बार जब आप OpenAI API कॉल करते हैं, आप किराया दे रहे हैं। हर बार जब आप लोकली मॉडल चलाते हैं, वो इंफ़रेंस इनिशियल सेटअप के बाद फ्री है। गणित सीधा है:

अगर आप ऐसी सर्विसेज़ बना रहे हैं जो हज़ारों रिक्वेस्ट प्रोसेस करती हैं, $0 और $5-$15 प्रति मिलियन टोकन के बीच का फ़र्क़ प्रॉफ़िट और ब्रेक-ईवन के बीच का फ़र्क़ है।

लेकिन यह बात ज़्यादातर लोग मिस करते हैं: लोकल और API मॉडल इनकम स्टैक में अलग-अलग रोल निभाते हैं। लोकल मॉडल वॉल्यूम हैंडल करते हैं। API मॉडल क्वालिटी-क्रिटिकल, कस्टमर-फेसिंग आउटपुट हैंडल करते हैं। आपके स्टैक में दोनों चाहिए।

Ollama इंस्टॉल करना

Ollama फ़ाउंडेशन है। यह आपकी मशीन को क्लीन API के साथ लोकल इंफ़रेंस सर्वर में बदल देता है।

# Linux
curl -fsSL https://ollama.com/install.sh | sh

# macOS
# Download from https://ollama.com or:
brew install ollama

# Windows
# Download installer from https://ollama.com
# Or use winget:
winget install Ollama.Ollama

इंस्टॉलेशन वेरिफ़ाई करें:

ollama --version
# Should show version 0.5.x or higher (check https://ollama.com/download for latest)

# Start the server (if not auto-started)
ollama serve

# In another terminal, test it:
ollama run llama3.1:8b "Say hello in exactly 5 words"

वर्शन नोट: Ollama बार-बार रिलीज़ करता है। इस मॉड्यूल में मॉडल कमांड्स और फ़्लैग्स Ollama v0.5.x (अर्ली 2026) के ख़िलाफ़ वेरिफ़ाई किए गए थे। अगर आप यह बाद में पढ़ रहे हैं, लेटेस्ट वर्शन के लिए ollama.com/download और करंट मॉडल नेम्स के लिए ollama.com/library चेक करें। कोर कॉन्सेप्ट्स नहीं बदलते, लेकिन स्पेसिफ़िक मॉडल टैग्स (जैसे llama3.1:8b) नए रिलीज़ से रिप्लेस हो सकते हैं।

मॉडल सेलेक्शन गाइड

हर मॉडल जो दिखे उसे डाउनलोड न करें। स्ट्रैटेजिक बनें। यह रहा क्या पुल करना है और हर एक कब इस्तेमाल करना है।

टियर 1: वर्कहॉर्स (7B-8B मॉडल)

# Pull your workhorse model
ollama pull llama3.1:8b
# Alternative: mistral (good for European languages)
ollama pull mistral:7b

इस्तेमाल करें:

परफ़ॉर्मेंस (टिपिकल):

कॉस्ट कम्पेरिज़न:

टियर 2: बैलेंस्ड चॉइस (13B-14B मॉडल)

# Pull your balanced model
ollama pull llama3.1:14b
# Or for coding tasks:
ollama pull deepseek-coder-v2:16b

इस्तेमाल करें:

परफ़ॉर्मेंस (टिपिकल):

7B की जगह कब इस्तेमाल करें: जब 7B की आउटपुट क्वालिटी काफ़ी अच्छी नहीं है लेकिन API कॉल्स के लिए पैसे नहीं देने। दोनों को अपने असल यूज़ केस पर टेस्ट करें — कभी-कभी 7B काफ़ी होता है और आप बस कंप्यूट बर्बाद कर रहे हैं।

टियर 3: क्वालिटी टियर (30B-70B मॉडल)

# Only pull these if you have the VRAM
# 30B needs ~20GB VRAM, 70B needs ~40GB VRAM (quantized)
ollama pull llama3.1:70b-instruct-q4_K_M
# Or the smaller but excellent:
ollama pull qwen2.5:32b

इस्तेमाल करें:

परफ़ॉर्मेंस (टिपिकल):

सीधी बात: अगर आपके पास 24GB+ VRAM नहीं है, 70B मॉडल पूरी तरह स्किप करें। क्वालिटी-क्रिटिकल आउटपुट के लिए API कॉल्स इस्तेमाल करें। सिस्टम RAM से 3 टोकन/सेकंड पर 70B मॉडल चलाना तकनीकी रूप से संभव है लेकिन किसी भी इनकम-जनरेटिंग वर्कफ़्लो के लिए प्रैक्टिकली बेकार है। आपके समय की क़ीमत है।

टियर 4: API मॉडल (जब लोकल काफ़ी नहीं है)

लोकल मॉडल वॉल्यूम और प्राइवेसी के लिए हैं। API मॉडल क्वालिटी सीलिंग्स और स्पेशलाइज़्ड कैपेबिलिटीज़ के लिए हैं।

API मॉडल कब इस्तेमाल करें:

कॉस्ट कम्पेरिज़न टेबल (अर्ली 2025 — करंट प्राइसिंग चेक करें):

मॉडल इनपुट (प्रति 1M टोकन) आउटपुट (प्रति 1M टोकन) बेस्ट फ़ॉर
GPT-4o-mini $0.15 $0.60 सस्ता वॉल्यूम वर्क (जब लोकल उपलब्ध नहीं)
GPT-4o $2.50 $10.00 विज़न, कॉम्प्लेक्स रीज़निंग
Claude 3.5 Sonnet $3.00 $15.00 कोड, एनालिसिस, लॉन्ग कॉन्टेक्स्ट
Claude 3.5 Haiku $0.80 $4.00 फ़ास्ट, सस्ता, अच्छी क्वालिटी बैलेंस
DeepSeek V3 $0.27 $1.10 बजट-फ्रेंडली, मज़बूत परफ़ॉर्मेंस

हाइब्रिड स्ट्रैटेजी:

  1. लोकल 7B/13B 80% रिक्वेस्ट हैंडल करता है (क्लासिफ़िकेशन, एक्सट्रैक्शन, समराइज़ेशन)
  2. API 20% रिक्वेस्ट हैंडल करता है (फ़ाइनल क्वालिटी पास, कॉम्प्लेक्स टास्क, कस्टमर-फेसिंग आउटपुट)
  3. आपकी इफ़ेक्टिव कॉस्ट प्रति टास्क प्योर API यूसेज की तुलना में नाटकीय रूप से गिरती है

यह हाइब्रिड अप्रोच है कि आप हेल्दी मार्जिन वाली सर्विसेज़ कैसे बनाते हैं। मॉड्यूल R में और बताएँगे।

प्रोडक्शन कॉन्फ़िगरेशन

इनकम वर्क के लिए Ollama चलाना पर्सनल चैट के लिए चलाने से अलग है। यह रहा इसे ठीक से कॉन्फ़िगर करने का तरीका।

एनवायरनमेंट वेरिएबल सेट करें

# Create/edit the Ollama configuration
# Linux: /etc/systemd/system/ollama.service or environment variables
# macOS: launchctl environment or ~/.zshrc
# Windows: System Environment Variables

# Key settings:
export OLLAMA_HOST=127.0.0.1:11434    # Bind to localhost only (security)
export OLLAMA_NUM_PARALLEL=4            # Concurrent request handling
export OLLAMA_MAX_LOADED_MODELS=2       # Keep 2 models in memory
export OLLAMA_KEEP_ALIVE=30m            # Keep model loaded for 30 min after last request
export OLLAMA_MAX_QUEUE=100             # Queue up to 100 requests

अपने वर्कलोड के लिए Modelfile बनाएँ

डिफ़ॉल्ट मॉडल सेटिंग्स इस्तेमाल करने के बजाय, अपने इनकम वर्कलोड के लिए ट्यून्ड कस्टम Modelfile बनाएँ:

# Save as: Modelfile-worker
FROM llama3.1:8b

# Tune for consistent, production output
PARAMETER temperature 0.3
PARAMETER top_p 0.9
PARAMETER num_ctx 4096
PARAMETER repeat_penalty 1.1

# System prompt for your most common workload
SYSTEM """You are a precise data processing assistant. You follow instructions exactly. You output only what is requested, with no preamble or explanation unless asked. When given structured output formats (JSON, CSV, etc.), you output only the structure with no markdown formatting."""

# Create your custom model
ollama create worker -f Modelfile-worker

# Test it
ollama run worker "Extract all email addresses from this text: Contact us at hello@example.com or support@test.org for more info."

बैचिंग और क्यू मैनेजमेंट

इनकम वर्कलोड के लिए, आपको अक्सर कई आइटम्स प्रोसेस करने होंगे। यह रहा एक बेसिक बैचिंग सेटअप:

#!/usr/bin/env python3
"""
batch_processor.py — Process items through local LLM with queuing.
Production-grade batching for income workloads.
"""

import requests
import json
import time
import concurrent.futures
from pathlib import Path

OLLAMA_URL = "http://127.0.0.1:11434/api/generate"
MODEL = "worker"  # Your custom model from above
MAX_CONCURRENT = 4
MAX_RETRIES = 3

def process_item(item: dict) -> dict:
    """Process a single item through the local LLM."""
    payload = {
        "model": MODEL,
        "prompt": item["prompt"],
        "stream": False,
        "options": {
            "num_ctx": 4096,
            "temperature": 0.3
        }
    }

    for attempt in range(MAX_RETRIES):
        try:
            response = requests.post(OLLAMA_URL, json=payload, timeout=120)
            response.raise_for_status()
            result = response.json()
            return {
                "id": item["id"],
                "input": item["prompt"][:100],
                "output": result["response"],
                "tokens": result.get("eval_count", 0),
                "duration_ms": result.get("total_duration", 0) / 1_000_000,
                "status": "success"
            }
        except Exception as e:
            if attempt == MAX_RETRIES - 1:
                return {
                    "id": item["id"],
                    "output": None,
                    "error": str(e),
                    "status": "failed"
                }
            time.sleep(2 ** attempt)  # Exponential backoff

def process_batch(items: list[dict], output_file: str = "results.jsonl"):
    """Process a batch of items with concurrent execution."""
    results = []
    start_time = time.time()

    with concurrent.futures.ThreadPoolExecutor(max_workers=MAX_CONCURRENT) as executor:
        future_to_item = {executor.submit(process_item, item): item for item in items}

        for i, future in enumerate(concurrent.futures.as_completed(future_to_item)):
            result = future.result()
            results.append(result)

            # Write incrementally (don't lose progress on crash)
            with open(output_file, "a") as f:
                f.write(json.dumps(result) + "\n")

            # Progress reporting
            elapsed = time.time() - start_time
            rate = (i + 1) / elapsed
            remaining = (len(items) - i - 1) / rate if rate > 0 else 0
            print(f"[{i+1}/{len(items)}] {result['status']} | "
                  f"{rate:.1f} items/sec | "
                  f"ETA: {remaining:.0f}s")

    # Summary
    succeeded = sum(1 for r in results if r["status"] == "success")
    failed = sum(1 for r in results if r["status"] == "failed")
    total_time = time.time() - start_time

    print(f"\nBatch complete: {succeeded} succeeded, {failed} failed, "
          f"{total_time:.1f}s total")

    return results

# Example usage:
if __name__ == "__main__":
    # Your items to process
    items = [
        {"id": i, "prompt": f"Summarize this in one sentence: {text}"}
        for i, text in enumerate(load_your_data())  # Replace with your data source
    ]

    results = process_batch(items)

अपने रिग का बेंचमार्क

किसी और के बेंचमार्क पर भरोसा न करें। अपना खुद मापें:

# Quick benchmark script
# Save as: benchmark.sh

#!/bin/bash
MODELS=("llama3.1:8b" "mistral:7b")
PROMPT="Write a detailed 200-word product description for a wireless mechanical keyboard designed for programmers."

for model in "${MODELS[@]}"; do
    echo "=== Benchmarking: $model ==="

    # Warm up (first run loads model into memory)
    ollama run "$model" "Hello" > /dev/null 2>&1

    # Timed run
    START=$(date +%s%N)
    RESULT=$(curl -s http://localhost:11434/api/generate -d "{
        \"model\": \"$model\",
        \"prompt\": \"$PROMPT\",
        \"stream\": false
    }")
    END=$(date +%s%N)

    DURATION=$(( (END - START) / 1000000 ))
    TOKENS=$(echo "$RESULT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('eval_count', 'N/A'))")

    echo "Time: ${DURATION}ms"
    echo "Tokens generated: $TOKENS"
    if [ "$TOKENS" != "N/A" ] && [ "$DURATION" -gt 0 ]; then
        TPS=$(python3 -c "print(f'{$TOKENS / ($DURATION / 1000):.1f}')")
        echo "Speed: $TPS tokens/second"
    fi
    echo ""
done

chmod +x benchmark.sh
./benchmark.sh

हर मॉडल के लिए अपना टोकन/सेकंड लिख लें। यह नंबर तय करता है कि कौन से इनकम वर्कफ़्लो आपके रिग के लिए प्रैक्टिकल हैं।

यूज़ केस के अनुसार स्पीड रिक्वायरमेंट:

अपने लोकल इंफ़रेंस सर्वर को सुरक्षित करें

आपका Ollama इंस्टेंस कभी भी इंटरनेट से एक्सेसिबल नहीं होना चाहिए जब तक आप जानबूझकर ऐसा न चाहें।

# Verify Ollama is only listening on localhost
ss -tlnp | grep 11434
# Should show 127.0.0.1:11434, NOT 0.0.0.0:11434

# If you need remote access (e.g., from another machine on your LAN):
# Use SSH tunneling instead of exposing the port
ssh -L 11434:localhost:11434 your-rig-ip

# Firewall rules (Linux)
sudo ufw deny in 11434
sudo ufw allow from 192.168.1.0/24 to any port 11434  # LAN only, if needed

आम गलती: "सुविधा" के लिए Ollama को 0.0.0.0 से बाइंड करना और इसे भूल जाना। जो कोई भी आपका IP ढूँढ ले वो आपके GPU का फ्री इंफ़रेंस के लिए इस्तेमाल कर सकता है। इससे भी बुरा, वो मॉडल वेट्स और सिस्टम प्रॉम्प्ट्स एक्सट्रैक्ट कर सकते हैं। हमेशा localhost। हमेशा टनल।

पाठ 2 चेकपॉइंट

आपके पास अब होना चाहिए:

पूरे STREETS कोर्स में, मॉड्यूल T (टेक्निकल मोट्स) दिखाता है कि प्रोप्राइटरी मॉडल कॉन्फ़िगरेशन, फ़ाइन-ट्यून्ड पाइपलाइन, और कस्टम टूलचेन कैसे बनाएँ जो कॉम्पिटिटर्स आसानी से रेप्लिकेट नहीं कर सकते। मॉड्यूल R (रेवेन्यू इंजन्स) इस स्टैक के ऊपर बनाने वाली सटीक सर्विसेज़ देता है।

पाठ 3: प्राइवेसी एडवांटेज

"आपका प्राइवेट सेटअप एक प्रतिस्पर्धात्मक लाभ है — सिर्फ़ प्रेफ़रेंस नहीं।"

प्राइवेसी एक प्रोडक्ट फ़ीचर है, सीमा नहीं

ज़्यादातर डेवलपर्स लोकल इंफ्रास्ट्रक्चर इसलिए सेट करते हैं क्योंकि वो व्यक्तिगत रूप से प्राइवेसी वैल्यू करते हैं, या टिंकरिंग एन्जॉय करते हैं। ठीक है। लेकिन अगर आप यह नहीं समझते कि प्राइवेसी अभी टेक में सबसे मार्केटेबल फ़ीचर्स में से एक है तो आप टेबल पर पैसे छोड़ रहे हैं।

यह रहा कारण: हर बार कोई कंपनी OpenAI के API को डेटा भेजती है, वो डेटा थर्ड पार्टी से होकर गुज़रता है। कई बिज़नेसेज़ के लिए — ख़ासकर हेल्थकेयर, फ़ाइनेंस, लीगल, गवर्नमेंट, और EU-बेस्ड कंपनियों — यह एक असली समस्या है। थ्योरेटिकल नहीं। "हम यह टूल इस्तेमाल नहीं कर सकते क्योंकि कंप्लायंस ने मना कर दिया" वाली समस्या।

आप, जो अपनी मशीन पर लोकली मॉडल चलाते हैं, आपको यह समस्या नहीं है।

रेगुलेटरी टेलविंड

रेगुलेटरी एनवायरनमेंट आपकी दिशा में मूव कर रहा है। तेज़ी से।

EU AI Act (2024-2026 से लागू):

GDPR (पहले से लागू):

इंडस्ट्री-स्पेसिफ़िक रेगुलेशन:

सेल्स कन्वर्सेशन में प्राइवेसी कैसे पोज़िशन करें

आपको कंप्लायंस एक्सपर्ट बनने की ज़रूरत नहीं। तीन फ़्रेज़ समझने और सही समय पर इस्तेमाल करने की ज़रूरत है:

फ़्रेज़ 1: "आपका डेटा कभी आपके इंफ्रास्ट्रक्चर से बाहर नहीं जाता।" कब इस्तेमाल करें: किसी भी प्राइवेसी-कॉन्शस प्रॉस्पेक्ट से बात करते समय। यह यूनिवर्सल हुक है।

फ़्रेज़ 2: "कोई थर्ड-पार्टी डेटा प्रोसेसिंग एग्रीमेंट ज़रूरी नहीं।" कब इस्तेमाल करें: यूरोपीयन कंपनियों या लीगल/कंप्लायंस टीम वाली किसी भी कंपनी से बात करते समय। यह उन्हें हफ्तों की लीगल रिव्यू बचाता है।

फ़्रेज़ 3: "पूरा ऑडिट ट्रेल, सिंगल-टेनेंट प्रोसेसिंग।" कब इस्तेमाल करें: एंटरप्राइज़ या रेगुलेटेड इंडस्ट्रीज़ से बात करते समय। उन्हें ऑडिटर्स को अपनी AI पाइपलाइन प्रूव करनी होती है।

पोज़िशनिंग का उदाहरण (आपकी सर्विस पेज या प्रपोज़ल के लिए):

"क्लाउड-बेस्ड AI सर्विसेज़ के विपरीत, [आपकी सर्विस] सभी डेटा को डेडिकेटेड हार्डवेयर पर लोकली प्रोसेस करती है। आपके डॉक्यूमेंट, कोड, और डेटा कभी प्रोसेसिंग एनवायरनमेंट से बाहर नहीं जाते। पाइपलाइन में कोई थर्ड-पार्टी API नहीं है, नेगोशिएट करने के लिए कोई डेटा शेयरिंग एग्रीमेंट नहीं, और हर ऑपरेशन की पूरी ऑडिट लॉगिंग। यह [आपकी सर्विस] को सख़्त डेटा हैंडलिंग रिक्वायरमेंट वाली ऑर्गनाइज़ेशन के लिए उपयुक्त बनाता है, जिसमें GDPR, HIPAA, और SOC 2 कंप्लायंस एनवायरनमेंट शामिल हैं।"

यह पैराग्राफ़, एक लैंडिंग पेज पर, बिल्कुल उन क्लाइंट्स को अट्रैक्ट करेगा जो प्रीमियम रेट्स पर पैसे देंगे।

प्रीमियम प्राइसिंग जस्टिफ़िकेशन

यह रहा हार्ड नंबर्स में बिज़नेस केस:

स्टैंडर्ड AI प्रोसेसिंग सर्विस (क्लाउड API इस्तेमाल करके):

प्राइवेसी-फ़र्स्ट AI प्रोसेसिंग सर्विस (आपका लोकल स्टैक):

प्राइवेसी प्रीमियम असली है: उसी अंडरलाइंग टास्क के लिए कमोडिटी क्लाउड-बेस्ड सर्विसेज़ से 5x से 10x ज़्यादा। और जो क्लाइंट्स इसे पे करते हैं वो ज़्यादा लॉयल, कम प्राइस-सेंसिटिव, और बड़ी बजट वाले होते हैं।

आइसोलेटेड वर्कस्पेस सेट करना

अगर आपकी डे जॉब है (ज़्यादातर लोगों की है), तो एम्प्लॉयर वर्क और इनकम वर्क के बीच क्लीन सेपरेशन चाहिए। यह सिर्फ़ लीगल प्रोटेक्शन नहीं — ऑपरेशनल हाइजीन है।

ऑप्शन 1: अलग यूज़र अकाउंट (रिकमेंडेड)

# Linux: Create a dedicated user for income work
sudo useradd -m -s /bin/bash income
sudo passwd income

# Switch to income user for all revenue work
su - income

# All income projects, API keys, and data live under /home/income/

ऑप्शन 2: कंटेनराइज़्ड वर्कस्पेस

# Docker-based isolation
# Create a dedicated workspace container

# docker-compose.yml
version: '3.8'
services:
  income-workspace:
    image: ubuntu:22.04
    volumes:
      - ./income-projects:/workspace
      - ./income-data:/data
    environment:
      - OLLAMA_HOST=host.docker.internal:11434
    network_mode: bridge
    # Your employer's VPN, tools, etc. are NOT in this container

ऑप्शन 3: अलग फ़िज़िकल मशीन (सबसे बुलेटप्रूफ़)

अगर आप इस बारे में गंभीर हैं और इनकम जस्टिफ़ाई करती है, तो एक डेडिकेटेड मशीन सारे सवाल ख़त्म कर देती है। RTX 3060 वाला यूज़्ड Dell OptiPlex $400-600 में आता है और पहले महीने के क्लाइंट वर्क में अपनी कॉस्ट रिकवर कर लेता है।

मिनिमम सेपरेशन चेकलिस्ट:

आम गलती: अपने साइड प्रोजेक्ट को "बस टेस्टिंग" के लिए एम्प्लॉयर का OpenAI API की इस्तेमाल करना। यह एक पेपर ट्रेल बनाता है जो आपके एम्प्लॉयर की बिलिंग डैशबोर्ड में दिखता है, और IP वॉटर्स मडी करता है। अपनी खुद की कीज़ लें। सस्ती हैं।

पाठ 3 चेकपॉइंट

आपको अब समझना चाहिए:

पूरे STREETS कोर्स में, मॉड्यूल E (इवॉल्विंग एज) सिखाता है कि रेगुलेटरी चेंजेज़ को कैसे ट्रैक करें और नई कंप्लायंस रिक्वायरमेंट से पहले खुद को पोज़िशन करें — इससे पहले कि आपके कॉम्पिटिटर्स को पता भी चले कि ये एक्ज़िस्ट करती हैं।

पाठ 4: न्यूनतम कानूनी ज़रूरतें

"अभी पंद्रह मिनट का लीगल सेटअप बाद में महीनों की समस्याएँ रोकता है।"

यह लीगल एडवाइस नहीं है

मैं एक डेवलपर हूँ, वकील नहीं। जो आगे है वो एक प्रैक्टिकल चेकलिस्ट है जिसे ज़्यादातर डेवलपर्स को ज़्यादातर सिचुएशन में एड्रेस करना चाहिए। अगर आपकी सिचुएशन कॉम्प्लेक्स है (एम्प्लॉयर में इक्विटी, स्पेसिफ़िक टर्म्स वाला नॉन-कॉम्पीट, आदि), एम्प्लॉयमेंट अटॉर्नी से 30-मिनट की कंसल्टेशन पर $200 खर्च करें। यह सबसे अच्छा ROI होगा जो आपको मिलेगा।

स्टेप 1: अपना एम्प्लॉयमेंट कॉन्ट्रैक्ट पढ़ें

अपना एम्प्लॉयमेंट कॉन्ट्रैक्ट या ऑफ़र लेटर ढूँढें। ये सेक्शन सर्च करें:

Intellectual Property Assignment क्लॉज़ — ऐसी भाषा ढूँढें:

मुख्य फ़्रेज़ जो आपको रिस्ट्रिक्ट करते हैं:

मुख्य फ़्रेज़ जो आपको फ्री करते हैं:

3 सवालों का टेस्ट

किसी भी इनकम प्रोजेक्ट के लिए, पूछें:

  1. समय: क्या आप यह काम अपने खुद के समय में कर रहे हैं? (वर्क ऑवर्स में नहीं, ऑन-कॉल शिफ्ट में नहीं)
  2. इक्विपमेंट: क्या आप अपना हार्डवेयर, अपना इंटरनेट, अपनी API कीज़ इस्तेमाल कर रहे हैं? (एम्प्लॉयर लैपटॉप नहीं, एम्प्लॉयर VPN नहीं, एम्प्लॉयर क्लाउड अकाउंट्स नहीं)
  3. सब्जेक्ट मैटर: क्या यह आपके एम्प्लॉयर के बिज़नेस से अनरिलेटेड है? (अगर आप हेल्थकेयर AI कंपनी में काम करते हैं और हेल्थकेयर AI सर्विसेज़ बेचना चाहते हैं... वो प्रॉब्लम है। अगर आप हेल्थकेयर AI कंपनी में काम करते हैं और रियल एस्टेट एजेंट्स के लिए डॉक्यूमेंट प्रोसेसिंग बेचना चाहते हैं... वो ठीक है।)

अगर तीनों जवाब क्लीन हैं, तो आप लगभग निश्चित रूप से ठीक हैं। अगर कोई जवाब मर्की है, आगे बढ़ने से पहले क्लैरिटी लें।

सीधी बात: साइड वर्क करने वाले अधिकांश डेवलपर्स को कभी कोई समस्या नहीं होती। एम्प्लॉयर्स कॉम्पिटिटिव एडवांटेज प्रोटेक्ट करने में इंटरेस्टेड हैं, अनरिलेटेड प्रोजेक्ट्स पर एक्स्ट्रा पैसे कमाने से रोकने में नहीं। लेकिन "लगभग निश्चित" का मतलब "बिल्कुल निश्चित" नहीं। अगर कॉन्ट्रैक्ट असामान्य रूप से ब्रॉड है, मैनेजर या HR से बात करें — या वकील से सलाह लें। चेक न करने का डाउनसाइड पूछने की हल्की ऑक्वर्डनेस से कहीं ज़्यादा बुरा है।

स्टेप 2: बिज़नेस स्ट्रक्चर चुनें

पर्सनल एसेट्स को बिज़नेस एक्टिविटीज़ से अलग करने के लिए लीगल एंटिटी चाहिए, और बिज़नेस बैंकिंग, पेमेंट प्रोसेसिंग, और टैक्स बेनिफ़िट्स का दरवाज़ा खोलने के लिए।

United States

स्ट्रक्चर कॉस्ट प्रोटेक्शन बेस्ट फ़ॉर
Sole Proprietorship (डिफ़ॉल्ट) $0 कोई नहीं (पर्सनल लायबिलिटी) पानी टेस्ट करना। पहले $1K।
Single-Member LLC $50-500 (स्टेट अनुसार अलग) पर्सनल एसेट प्रोटेक्शन एक्टिव इनकम वर्क। ज़्यादातर डेवलपर्स यहाँ से शुरू करें।
S-Corp इलेक्शन (LLC पर) LLC कॉस्ट + इलेक्शन के लिए $0 LLC जैसा + पेरोल टैक्स बेनिफ़िट्स जब कंसिस्टेंटली $40K+/साल कमा रहे हों

US डेवलपर्स के लिए रिकमेंडेड: आपके रेज़िडेंस स्टेट में Single-Member LLC।

फ़ॉर्म करने के लिए सबसे सस्ते स्टेट: Wyoming ($100, कोई स्टेट इनकम टैक्स नहीं), New Mexico ($50), Montana ($70)। लेकिन अपने होम स्टेट में फ़ॉर्म करना आमतौर पर सबसे सिंपल है जब तक स्पेसिफ़िक कारण न हो।

फ़ाइल कैसे करें:

  1. अपने स्टेट की Secretary of State वेबसाइट पर जाएँ
  2. "form LLC" या "business entity filing" सर्च करें
  3. Articles of Organization फ़ाइल करें (10-मिनट का फ़ॉर्म)
  4. IRS से EIN लें (फ्री, irs.gov पर 5 मिनट लगते हैं)

United Kingdom

स्ट्रक्चर कॉस्ट प्रोटेक्शन बेस्ट फ़ॉर
Sole Trader फ्री (HMRC से रजिस्टर) कोई नहीं पहली इनकम। टेस्टिंग।
Limited Company (Ltd) ~$15 Companies House से पर्सनल एसेट प्रोटेक्शन कोई भी गंभीर इनकम वर्क।

रिकमेंडेड: Companies House से Ltd कंपनी। लगभग 20 मिनट लगते हैं और GBP 12 कॉस्ट है।

European Union

देश के अनुसार काफ़ी अलग-अलग, लेकिन जनरल पैटर्न:

Australia

स्ट्रक्चर कॉस्ट प्रोटेक्शन बेस्ट फ़ॉर
Sole Trader फ्री ABN कोई नहीं शुरुआत
Pty Ltd ~AUD 500-800 ASIC से पर्सनल एसेट प्रोटेक्शन गंभीर इनकम

रिकमेंडेड: Sole Trader ABN (फ्री, इंस्टेंट) से शुरू करें, कंसिस्टेंटली कमाने लगें तब Pty Ltd पर मूव करें।

स्टेप 3: पेमेंट प्रोसेसिंग (15-मिनट सेटअप)

पैसे लेने का तरीका चाहिए। यह अभी सेट करें, पहला क्लाइंट इंतज़ार करे तब नहीं।

Stripe (ज़्यादातर डेवलपर्स के लिए रिकमेंडेड):

1. Go to stripe.com
2. Create account with your business email
3. Complete identity verification
4. Connect your business bank account
5. You can now accept payments, create invoices, and set up subscriptions

समय: ~15 मिनट। तुरंत पेमेंट एक्सेप्ट करना शुरू कर सकते हैं (Stripe नए अकाउंट पर 7 दिन फ़ंड होल्ड करता है)।

Lemon Squeezy (डिजिटल प्रोडक्ट्स के लिए रिकमेंडेड):

अगर डिजिटल प्रोडक्ट्स बेच रहे हैं (टेम्पलेट, टूल्स, कोर्सेज़, SaaS), Lemon Squeezy आपके Merchant of Record के रूप में काम करता है। इसका मतलब:

1. Go to lemonsqueezy.com
2. Create account
3. Set up your store
4. Add products
5. They handle everything else

Stripe Atlas (इंटरनेशनल डेवलपर्स या US एंटिटी चाहने वालों के लिए):

अगर US के बाहर हैं लेकिन US एंटिटी से US कस्टमर्स को बेचना चाहते हैं:

स्टेप 4: प्राइवेसी पॉलिसी और Terms of Service

अगर ऑनलाइन कोई सर्विस या प्रोडक्ट बेच रहे हैं, ये चाहिए। बॉयलरप्लेट के लिए वकील को पैसे न दें।

टेम्पलेट के लिए फ्री, रिप्यूटेबल सोर्सेज़:

प्राइवेसी पॉलिसी में क्या कवर होना चाहिए (अगर कोई क्लाइंट डेटा प्रोसेस कर रहे हैं):

समय: टेम्पलेट जनरेटर के साथ 30 मिनट। हो गया।

स्टेप 5: अलग बैंक अकाउंट

बिज़नेस इनकम पर्सनल चेकिंग अकाउंट से न चलाएँ। कारण:

  1. टैक्स क्लैरिटी: टैक्स टाइम पर, बिल्कुल पता होना चाहिए क्या बिज़नेस इनकम थी और क्या नहीं।
  2. लीगल प्रोटेक्शन: अगर LLC है, पर्सनल और बिज़नेस फ़ंड्स मिलाना "कॉर्पोरेट वेल पियर्स" कर सकता है — मतलब कोर्ट आपके LLC की लायबिलिटी प्रोटेक्शन इग्नोर कर सकती है।
  3. प्रोफ़ेशनलिज़्म: "जॉन'स कंसल्टिंग LLC" से इनवॉइस डेडिकेटेड बिज़नेस अकाउंट में आना लेजिटिमेट दिखता है। पर्सनल Venmo में पेमेंट नहीं।

फ्री या लो-कॉस्ट बिज़नेस बैंकिंग:

अकाउंट अभी खोलें। ऑनलाइन 10-15 मिनट लगते हैं और वेरिफ़िकेशन में 1-3 दिन।

स्टेप 6: डेवलपर साइड इनकम के लिए टैक्स बेसिक्स

सीधी बात: टैक्स वो चीज़ है जिसे ज़्यादातर डेवलपर्स अप्रैल तक इग्नोर करते हैं, और फिर पैनिक करते हैं। अभी 30 मिनट खर्च करना आपके असली पैसे और स्ट्रेस बचाता है।

United States:

डेवलपर साइड इनकम के लिए कॉमन राइट-ऑफ़:

United Kingdom:

पहले दिन से सब कुछ ट्रैक करें। कुछ न हो तो सिंपल स्प्रेडशीट इस्तेमाल करें:

| Date       | Category    | Description          | Amount  | Type    |
|------------|-------------|----------------------|---------|---------|
| 2025-01-15 | API         | Anthropic credit     | -$20.00 | Expense |
| 2025-01-18 | Revenue     | Client invoice #001  | +$500.00| Income  |
| 2025-01-20 | Software    | Vercel Pro plan      | -$20.00 | Expense |
| 2025-01-20 | Tax Reserve | 30% of net income    | -$138.00| Transfer|

आम गलती: "टैक्स बाद में फ़िगर कर लूँगा।" बाद में Q4 है, एस्टिमेटेड टैक्स में $3,000 देना है प्लस पेनल्टी, और पैसे खर्च हो चुके हैं। ऑटोमेट करें: जब भी बिज़नेस अकाउंट में इनकम आए, तुरंत 30% टैक्स सेविंग्स अकाउंट में ट्रांसफ़र करें।

पाठ 4 चेकपॉइंट

आपके पास अब (या प्लान) होना चाहिए:

पूरे STREETS कोर्स में, मॉड्यूल E (एक्ज़ीक्यूशन प्लेबुक) में फ़ाइनेंशियल मॉडलिंग टेम्पलेट्स हैं जो ऑटोमैटिकली टैक्स ऑब्लिगेशन, प्रोजेक्ट प्रॉफ़िटेबिलिटी, और हर रेवेन्यू इंजन के ब्रेक-ईवन पॉइंट कैलकुलेट करते हैं।

पाठ 5: $200/महीने का बजट

"आपके बिज़नेस की बर्न रेट है। जानो। कंट्रोल करो। कमाओ।"

$200/महीने क्यों

दो सौ dollars प्रति महीना डेवलपर इनकम ऑपरेशन के लिए मिनिमम वाइएबल बजट है। यह काफ़ी है रियल सर्विसेज़ चलाने, रियल कस्टमर्स सर्व करने, और रियल रेवेन्यू जनरेट करने के लिए। और यह इतना छोटा भी है कि अगर कुछ काम नहीं करता, तो सब कुछ दांव पर नहीं लगाया।

गोल सिंपल है: $200/महीने को 90 दिनों में $600+/महीने में बदलो। अगर कर सकते हो, तो बिज़नेस है। अगर नहीं कर सकते, स्ट्रैटेजी बदलो — बजट नहीं।

बजट ब्रेकडाउन

टियर 1: API क्रेडिट्स — $50-100/महीने

यह कस्टमर-फेसिंग क्वालिटी के लिए आपका प्रोडक्शन कंप्यूट है।

रिकमेंडेड स्टार्टिंग एलोकेशन:

Anthropic (Claude):     $40/month  — Your primary for quality output
OpenAI (GPT-4o-mini):   $20/month  — Cheap volume work, fallback
DeepSeek:               $10/month  — Budget tasks, experimentation
Buffer:                 $30/month  — Overflow or new provider testing

API स्पेंड कैसे मैनेज करें:

# Simple API budget tracker — run daily via cron
# Save as: check_api_spend.py

import requests
import json
from datetime import datetime

# Check Anthropic usage
# (Anthropic provides usage in the dashboard; here's how to track locally)

MONTHLY_BUDGET = {
    "anthropic": 40.00,
    "openai": 20.00,
    "deepseek": 10.00,
}

# Track locally by logging every API call cost
USAGE_LOG = "api_usage.jsonl"

def get_monthly_spend(provider: str) -> float:
    """Calculate current month's spend for a provider."""
    current_month = datetime.now().strftime("%Y-%m")
    total = 0.0
    try:
        with open(USAGE_LOG, "r") as f:
            for line in f:
                entry = json.loads(line)
                if entry["provider"] == provider and entry["date"].startswith(current_month):
                    total += entry["cost"]
    except FileNotFoundError:
        pass
    return total

def log_api_call(provider: str, tokens_in: int, tokens_out: int, model: str):
    """Log an API call for budget tracking."""
    # Cost per 1M tokens (update these as pricing changes)
    PRICING = {
        "claude-3.5-sonnet": {"input": 3.00, "output": 15.00},
        "claude-3.5-haiku": {"input": 0.80, "output": 4.00},
        "gpt-4o-mini": {"input": 0.15, "output": 0.60},
        "gpt-4o": {"input": 2.50, "output": 10.00},
        "deepseek-v3": {"input": 0.27, "output": 1.10},
    }

    prices = PRICING.get(model, {"input": 1.0, "output": 5.0})
    cost = (tokens_in / 1_000_000 * prices["input"]) + \
           (tokens_out / 1_000_000 * prices["output"])

    entry = {
        "date": datetime.now().isoformat(),
        "provider": provider,
        "model": model,
        "tokens_in": tokens_in,
        "tokens_out": tokens_out,
        "cost": round(cost, 6),
    }

    with open(USAGE_LOG, "a") as f:
        f.write(json.dumps(entry) + "\n")

    # Budget warning
    monthly_spend = get_monthly_spend(provider)
    budget = MONTHLY_BUDGET.get(provider, 0)
    if monthly_spend > budget * 0.8:
        print(f"WARNING: {provider} spend at {monthly_spend:.2f}/{budget:.2f} "
              f"({monthly_spend/budget*100:.0f}%)")

    return cost

हाइब्रिड स्पेंड स्ट्रैटेजी:

टियर 2: इंफ्रास्ट्रक्चर — $30-50/महीने

Domain name:            $12/year ($1/month)     — Namecheap, Cloudflare, Porkbun
Email (business):       $0-6/month              — Zoho Mail free, or Google Workspace $6
VPS (optional):         $5-20/month             — For hosting lightweight services
                                                  Hetzner ($4), DigitalOcean ($6), Railway ($5)
DNS/CDN:                $0/month                — Cloudflare free tier
Hosting (static):       $0/month                — Vercel, Netlify, Cloudflare Pages (free tiers)

VPS चाहिए?

अगर आपका इनकम मॉडल है:

रिकमेंडेड स्टार्टर इंफ्रास्ट्रक्चर:

Local rig — primary compute, LLM inference, heavy processing
   |
   +-- SSH tunnel or WireGuard VPN
   |
$5 VPS (Hetzner/DigitalOcean) — API gateway, webhook receiver, static hosting
   |
   +-- Cloudflare (free) — DNS, CDN, DDoS protection
   |
Vercel/Netlify (free) — marketing site, landing pages, docs

टोटल इंफ्रास्ट्रक्चर कॉस्ट: $5-20/महीने। बाकी फ्री टियर।

टियर 3: टूल्स — $20-30/महीने

Analytics:              $0/month    — Plausible Cloud ($9) or self-hosted,
                                      or Vercel Analytics (free tier)
                                      or just Cloudflare analytics (free)
Email marketing:        $0/month    — Buttondown (free up to 100 subs),
                                      Resend ($0 for 3K emails/month)
Monitoring:             $0/month    — UptimeRobot (free, 50 monitors),
                                      Better Stack (free tier)
Design:                 $0/month    — Figma (free), Canva (free tier)
Accounting:             $0/month    — Wave (free), or a spreadsheet
                                      Hledger (free, plaintext accounting)

सीधी बात: शुरू करते समय पूरा टूल स्टैक फ्री टियर पर चला सकते हैं। यहाँ एलोकेट किए $20-30 तब के लिए हैं जब फ्री टियर आउटग्रो करें या कोई स्पेसिफ़िक प्रीमियम फ़ीचर चाहें। बस बजट में है इसलिए खर्च न करें। अनस्पेंट बजट प्रॉफ़िट है।

टियर 4: रिज़र्व — $0-30/महीने

यह "जो एंटिसिपेट नहीं किया" फ़ंड है:

अगर रिज़र्व यूज़ नहीं होता, एक्यूम्युलेट होता है। 3 महीने अनयूज़्ड रिज़र्व के बाद, API क्रेडिट्स या इंफ्रास्ट्रक्चर में रीएलोकेट करने पर विचार करें।

ROI कैलकुलेशन

सिर्फ़ यही एक नंबर मायने रखता है:

Monthly Revenue - Monthly Costs = Net Profit
Net Profit / Monthly Costs = ROI Multiple

Example:
$600 revenue - $200 costs = $400 profit
$400 / $200 = 2x ROI

The target: 3x ROI ($600+ revenue on $200 spend)
The minimum: 1x ROI ($200 revenue = break even)
Below 1x: Change strategy or reduce costs

बजट कब बढ़ाएँ:

बजट सिर्फ़ तब बढ़ाएँ जब:

  1. 2+ महीनों से कंसिस्टेंटली 2x+ ROI हो
  2. ज़्यादा खर्च सीधे रेवेन्यू बढ़ाए (जैसे: ज़्यादा API क्रेडिट्स = ज़्यादा क्लाइंट कैपेसिटी)
  3. बढ़ोतरी किसी स्पेसिफ़िक, टेस्टेड रेवेन्यू स्ट्रीम से जुड़ी हो

बजट कब न बढ़ाएँ:

स्केलिंग लैडर:

$200/month  → Proving the concept (months 1-3)
$500/month  → Scaling what works (months 4-6)
$1000/month → Multiple revenue streams (months 6-12)
$2000+/month → Full business operation (year 2+)

Each step requires proving ROI at the current level first.

आम गलती: $200 को "इनवेस्टमेंट" मानना जिसे तुरंत रिटर्न नहीं चाहिए। नहीं। यह 90-दिन की डेडलाइन वाला एक्सपेरिमेंट है। अगर $200/महीने 90 दिनों में $200/महीने रेवेन्यू जनरेट नहीं करता, स्ट्रैटेजी में कुछ बदलना चाहिए। पैसा, मार्केट, ऑफ़र — कुछ काम नहीं कर रहा। अपने आप से ईमानदार रहें।

पाठ 5 चेकपॉइंट

आपके पास अब होना चाहिए:

पूरे STREETS कोर्स में, मॉड्यूल E (एक्ज़ीक्यूशन प्लेबुक) में फ़ाइनेंशियल डैशबोर्ड टेम्पलेट है जो आपका स्पेंड, रेवेन्यू, और ROI प्रति रेवेन्यू इंजन रियल-टाइम में ट्रैक करता है — ताकि आप हमेशा जानें कौन से स्ट्रीम्स प्रॉफ़िटेबल हैं और कौन से एडजस्टमेंट चाहते हैं।

पाठ 6: आपका सॉवरेन स्टैक डॉक्यूमेंट

"हर बिज़नेस का एक प्लान होता है। यह आपका है — और दो पेज में आ जाता है।"

डिलीवरेबल

यह मॉड्यूल S में आपकी सबसे ज़रूरी चीज़ है। सॉवरेन स्टैक डॉक्यूमेंट एक सिंगल रेफ़रेंस है जो आपके इनकम-जनरेटिंग इंफ्रास्ट्रक्चर के बारे में सब कुछ कैप्चर करता है। बाकी STREETS कोर्स में इसे रेफ़र करेंगे, सेटअप इवॉल्व होने पर अपडेट करेंगे, और क्या बनाना है क्या स्किप करना है के बारे में क्लीयर-हेडेड डिसीज़न लेने के लिए इस्तेमाल करेंगे।

नई फ़ाइल बनाएँ। Markdown, Google Doc, Notion पेज, प्लेन टेक्स्ट — जो भी आप वाकई मेंटेन करेंगे। नीचे का टेम्पलेट इस्तेमाल करें, हर फ़ील्ड पाठ 1-5 के नंबर और डिसीज़न से भरें।

टेम्पलेट

यह पूरा टेम्पलेट कॉपी करें और भरें। हर फ़ील्ड। बिना स्किप।

# Sovereign Stack Document
# [Your Name or Business Name]
# Created: [Date]
# Last Updated: [Date]

---

## 1. HARDWARE INVENTORY

### Primary Machine
- **Type:** [Desktop / Laptop / Mac / Server]
- **CPU:** [Model] — [X] cores, [X] threads
- **RAM:** [X] GB [DDR4/DDR5]
- **GPU:** [Model] — [X] GB VRAM (or "None — CPU inference only")
- **Storage:** [X] GB SSD free / [X] GB total
- **OS:** [Linux distro / macOS version / Windows version]

### Network
- **Download:** [X] Mbps
- **Upload:** [X] Mbps
- **Latency to cloud APIs:** [X] ms
- **ISP reliability:** [Stable / Occasional outages / Unreliable]

### Uptime Capability
- **Can run 24/7:** [Yes / No — reason]
- **UPS:** [Yes / No]
- **Remote access:** [SSH / RDP / Tailscale / None]

### Monthly Infrastructure Cost
- **Electricity (24/7 estimate):** $[X]/month
- **Internet:** $[X]/month (business portion)
- **Total fixed infrastructure cost:** $[X]/month

---

## 2. LLM STACK

### Local Models (via Ollama)
| Model | Size | Tokens/sec | Use Case |
|-------|------|-----------|----------|
| [e.g., llama3.1:8b] | [X]B | [X] tok/s | [e.g., Classification, extraction] |
| [e.g., mistral:7b] | [X]B | [X] tok/s | [e.g., Summarization, drafts] |
| [e.g., deepseek-coder] | [X]B | [X] tok/s | [e.g., Code generation] |

### API Models (for quality-critical output)
| Provider | Model | Monthly Budget | Use Case |
|----------|-------|---------------|----------|
| [e.g., Anthropic] | [Claude 3.5 Sonnet] | $[X] | [e.g., Customer-facing content] |
| [e.g., OpenAI] | [GPT-4o-mini] | $[X] | [e.g., Volume processing fallback] |

### Inference Strategy
- **Local handles:** [X]% of requests ([list tasks])
- **API handles:** [X]% of requests ([list tasks])
- **Estimated blended cost per 1M tokens:** $[X]

---

## 3. MONTHLY BUDGET

| Category | Allocation | Actual (update monthly) |
|----------|-----------|------------------------|
| API Credits | $[X] | $[  ] |
| Infrastructure (VPS, domain, email) | $[X] | $[  ] |
| Tools (analytics, email marketing) | $[X] | $[  ] |
| Reserve | $[X] | $[  ] |
| **Total** | **$[X]** | **$[  ]** |

### Revenue Target
- **Month 1-3:** $[X]/month (minimum: cover costs)
- **Month 4-6:** $[X]/month
- **Month 7-12:** $[X]/month

---

## 4. LEGAL STATUS

- **Employment status:** [Employed / Freelance / Between jobs]
- **IP clause reviewed:** [Yes / No / N/A]
- **IP clause risk level:** [Clean / Murky — needs review / Restrictive]
- **Business entity:** [LLC / Ltd / Sole Proprietor / None yet]
  - **State/Country:** [Where registered]
  - **EIN/Tax ID:** [Obtained / Pending / Not needed yet]
- **Payment processing:** [Stripe / Lemon Squeezy / Other] — [Active / Pending]
- **Business bank account:** [Open / Pending / Using personal (fix this)]
- **Privacy policy:** [Done / Not yet — URL: ___]
- **Terms of service:** [Done / Not yet — URL: ___]

---

## 5. TIME INVENTORY

- **Available hours per week for income projects:** [X] hours
  - **Weekday mornings:** [X] hours
  - **Weekday evenings:** [X] hours
  - **Weekends:** [X] hours
- **Time zone:** [Your timezone]
- **Best deep work blocks:** [e.g., "Saturday 6am-12pm, weekday evenings 8-10pm"]

### Time Allocation Plan
| Activity | Hours/week |
|----------|-----------|
| Building/coding | [X] |
| Marketing/sales | [X] |
| Client work/delivery | [X] |
| Learning/experimentation | [X] |
| Admin (invoicing, email, etc.) | [X] |

> Rule: Never allocate more than 70% of available time.
> Life happens. Burnout is real. Leave buffer.

---

## 6. SKILLS INVENTORY

### Primary Skills (things you could teach others)
1. [Skill] — [years of experience]
2. [Skill] — [years of experience]
3. [Skill] — [years of experience]

### Secondary Skills (competent but not expert)
1. [Skill]
2. [Skill]
3. [Skill]

### Exploring (learning now or want to learn)
1. [Skill]
2. [Skill]

### Unique Combinations
What makes YOUR skill combination unusual? (This becomes your moat in Module T)
- [e.g., "I know both Rust AND healthcare data standards — very few people have both"]
- [e.g., "I can build full-stack apps AND I understand supply chain logistics from a previous career"]
- [e.g., "I'm fluent in 3 languages AND I can code — I can serve non-English markets that most dev tools ignore"]

---

## 7. SOVEREIGN STACK SUMMARY

### What I Can Offer Today
(Based on hardware + skills + time, what could you sell THIS WEEK if someone asked?)
1. [e.g., "Local document processing — extract data from PDFs privately"]
2. [e.g., "Custom automation scripts for [specific domain]"]
3. [e.g., "Technical writing / documentation"]

### What I'm Building Toward
(Based on the full STREETS framework — fill this in as you progress through the playbook)
1. [Revenue Engine 1 — from Module R]
2. [Revenue Engine 2 — from Module R]
3. [Revenue Engine 3 — from Module R]

### Key Constraints
(Be honest — these aren't weaknesses, they're parameters)
- [e.g., "Only 10 hours/week available"]
- [e.g., "No GPU — CPU inference only, will rely on APIs for LLM tasks"]
- [e.g., "Employment contract is restrictive — need to stay in unrelated domains"]
- [e.g., "Non-US based — some payment/legal options are limited"]

---

*This document is a living reference. Update it monthly.*
*Next review date: [Date + 30 days]*

यह डॉक्यूमेंट कैसे इस्तेमाल करें

  1. कोई भी नया प्रोजेक्ट शुरू करने से पहले: सॉवरेन स्टैक चेक करें। क्या हार्डवेयर, टाइम, स्किल्स, और बजट है एक्ज़ीक्यूट करने के लिए?
  2. कुछ भी खरीदने से पहले: बजट एलोकेशन चेक करें। क्या यह परचेज प्लान में है?
  3. मंथली रिव्यू: बजट में "Actual" कॉलम अपडेट करें। रेवेन्यू नंबर अपडेट करें। जो काम कर रहा है उसके बेसिस पर एलोकेशन एडजस्ट करें।
  4. जब कोई पूछे आप क्या करते हैं: "What I Can Offer Today" सेक्शन आपकी इंस्टेंट पिच है।
  5. जब कोई चमकदार नया आइडिया लुभाए: अपने कंस्ट्रेंट्स चेक करें। क्या यह टाइम, स्किल्स, और हार्डवेयर में फ़िट होता है? अगर नहीं, "Building Toward" में बाद के लिए एड करें।

एक घंटे की एक्सरसाइज़

60 मिनट का टाइमर लगाएँ। टेम्पलेट का हर फ़ील्ड भरें। ज़्यादा न सोचें। एक्सटेंसिव रिसर्च न करें। जो अभी जानते हैं वो लिखें। बाद में अपडेट कर सकते हैं।

जो फ़ील्ड भर नहीं सकते? वो इस हफ़्ते के एक्शन आइटम हैं:

आम गलती: डॉक्यूमेंट "परफ़ेक्ट" बनाने में 3 घंटे लगाना बजाय "डन" बनाने में 1 घंटा। सॉवरेन स्टैक डॉक्यूमेंट एक वर्किंग रेफ़रेंस है, इनवेस्टर्स के लिए बिज़नेस प्लान नहीं। आपके अलावा कोई नहीं देखेगा। एक्युरेसी मायने रखती है। फ़ॉर्मेटिंग नहीं।

पाठ 6 चेकपॉइंट

आपके पास अब होना चाहिए:

मॉड्यूल S: कम्प्लीट

दो हफ्तों में आपने क्या बनाया

देखें आपके पास अब क्या है जो शुरू करते वक्त नहीं था:

  1. हार्डवेयर इन्वेंटरी इनकम-जनरेटिंग कैपेबिलिटीज़ से मैप्ड — सिर्फ़ स्टिकर पर स्पेक्स नहीं।
  2. प्रोडक्शन-ग्रेड लोकल LLM स्टैक Ollama के साथ, आपके असल हार्डवेयर पर बेंचमार्क्ड, रियल वर्कलोड के लिए कॉन्फ़िगर्ड।
  3. प्राइवेसी एडवांटेज जिसे मार्केट करना आप जानते हैं — स्पेसिफ़िक ऑडियंस के लिए स्पेसिफ़िक लैंग्वेज।
  4. लीगल और फ़ाइनेंशियल फ़ाउंडेशन — बिज़नेस एंटिटी (या प्लान), पेमेंट प्रोसेसिंग, बैंक अकाउंट, टैक्स स्ट्रैटेजी।
  5. कंट्रोल्ड बजट क्लीयर ROI टार्गेट और मॉडल प्रूव करने की 90-दिन डेडलाइन के साथ।
  6. सॉवरेन स्टैक डॉक्यूमेंट जो ऊपर सब कुछ एक सिंगल रेफ़रेंस में कैप्चर करता है जो आगे हर डिसीज़न के लिए इस्तेमाल करेंगे।

यह ज़्यादातर डेवलपर्स जितना सेट करते हैं उससे ज़्यादा है। सीरियसली। ज़्यादातर लोग जो साइड इनकम चाहते हैं सीधे "कुछ कूल बनाओ" पर कूद जाते हैं और फिर सोचते हैं कि पैसे क्यों नहीं मिल रहे। आपके पास अब पैसे पाने का इंफ्रास्ट्रक्चर है।

लेकिन दिशा के बिना इंफ्रास्ट्रक्चर बस एक महंगी हॉबी है। आपको जानना होगा कि इस स्टैक को कहाँ एम करें।

आगे क्या: मॉड्यूल T — टेक्निकल मोट्स

मॉड्यूल S ने फ़ाउंडेशन दिया। मॉड्यूल T क्रिटिकल सवाल का जवाब देता है: ऐसा कुछ कैसे बनाएँ जो कॉम्पिटिटर्स आसानी से कॉपी न कर सकें?

मॉड्यूल T यह कवर करता है:

$500/महीने कमाने वाले डेवलपर और $5,000/महीने कमाने वाले में फ़र्क़ शायद ही कभी स्किल होता है। मोट्स होती हैं। वो चीज़ें जो आपकी ऑफ़रिंग को हार्ड टू रेप्लिकेट बनाती हैं, भले ही किसी के पास वही हार्डवेयर और वही मॉडल हों।

पूरा STREETS रोडमैप

मॉड्यूल टाइटल फ़ोकस अवधि
S सॉवरेन सेटअप इंफ्रास्ट्रक्चर, कानूनी, बजट सप्ताह 1-2 (कम्प्लीट)
T टेक्निकल मोट्स डिफ़ेंसिबल एडवांटेज, प्रोप्राइटरी एसेट्स सप्ताह 3-4
R रेवेन्यू इंजन्स कोड सहित स्पेसिफ़िक मॉनेटाइज़ेशन प्लेबुक सप्ताह 5-8
E एक्ज़ीक्यूशन प्लेबुक लॉन्च सीक्वेंसेज़, प्राइसिंग, पहले कस्टमर्स सप्ताह 9-10
E इवॉल्विंग एज आगे रहना, ट्रेंड डिटेक्शन, अडैप्टेशन सप्ताह 11-12
T टैक्टिकल ऑटोमेशन पैसिव इनकम के लिए ऑपरेशन ऑटोमेट करना सप्ताह 13-14
S स्टैकिंग स्ट्रीम्स मल्टीपल इनकम सोर्सेज़, पोर्टफ़ोलियो स्ट्रैटेजी सप्ताह 15-16

मॉड्यूल R (रेवेन्यू इंजन्स) वो है जहाँ ज़्यादातर पैसे बनते हैं। लेकिन S और T के बिना, रेत पर बना रहे हैं।

पूरे प्लेबुक के लिए तैयार?

आपने फ़ाउंडेशन देखा है। खुद बनाया है। अब पूरा सिस्टम पाएँ।

STREETS Core पाएँ — पूरा 16-हफ़्ते का कोर्स सातों मॉड्यूल के साथ, रेवेन्यू इंजन कोड टेम्पलेट्स, फ़ाइनेंशियल डैशबोर्ड, और डेवलपर्स का प्राइवेट कम्युनिटी जो अपनी शर्तों पर इनकम बना रहे हैं।

आपका रिग। आपके नियम। आपकी कमाई।

अगला → मॉड्यूल T: टेक्निकल मोट्स