Raspberry Pi AI సమూహాన్ని ఆర్థికంగా ఎయిర్-గ్యాప్ చేయడం

నా మూడు Raspberry Pi 5 (16GB + M.2 256GB) నోడ్‌లలో ఒకదాన్ని వేరు చేశాను, అది మాస్టర్ కంట్రోల్ ప్రోగ్రామ్ (MCP) నియంత్రించే, ఆర్థికంగా ఎయిర్-గ్యాప్ చేసిన AI ఆర్కెస్ట్రేటర్‌గా పనిచేయడానికి. లక్ష్యం నేను రోజూ వాడగలిగే సామర్థ్యం గల, బహుళ-ప్రయోజన AI సహాయక వ్యవస్థను నిర్మించడం, నిరంతర స్టేట్-నిర్వహణ వల్ల నా “Pro” టియర్ API బిల్లు పూర్తిగా ఆవిరైపోకుండా.

ఈ వ్యవస్థలోని వర్కర్లు సంకుచితమైన, ఏకైక-ప్రయోజన డెమన్‌లు కాదు. వారు పూర్తిగా పనిచేసే వ్యక్తిగత సహాయకులు: సిస్టమ్‌లను చురుగ్గా గమనిస్తారు, స్వయంప్రతిపత్త బ్యాక్‌గ్రౌండ్ పనులు నిర్వహిస్తారు, వ్యక్తిగత ఉత్పాదకత టూల్స్‌తో అనుసంధానమవుతారు, Telegram ద్వారా ప్రశ్నలకు జవాబిస్తారు. అయినా ఇంత సామర్థ్యం గల సహాయకులను నడపడానికి ఒక రక్షణ కావాలి. పరిష్కారం ఒక దూకుడు రూటింగ్ వ్యూహం: వాతావరణాన్ని పర్యవేక్షించడానికి కేంద్ర MCP ని వాడటం, అసలు సహాయకులు ఖాతా-స్థాయి కఠిన ఖర్చు పరిమితులున్న అగ్రిగేటర్ ద్వారా డాకరైజ్డ్ బ్యాక్‌గ్రౌండ్ ప్రాసెస్‌లుగా నడవడం. Pi ఇకపై సాధారణ-ప్రయోజన హోమ్ ల్యాబ్ కాదు: దాన్ని అంకితమైన, నెట్‌వర్క్‌తో కూడిన OpenClaw షెల్‌గా చేయడానికి మిగతా ప్రతి కంటైనర్‌నూ తొలగించాను.

ఆర్కిటెక్చర్

వ్యవస్థ స్ప్లిట్-బ్రెయిన్, శ్రేణీకృత ఆర్కిటెక్చర్‌పై పనిచేస్తుంది. మూలంలో MCP ఉంది. ఒకే ఖరీదైన మోడల్‌ను హార్డ్‌కోడ్ చేయడానికి బదులు, MCP ఒక manifest.ai స్కిల్‌ను అంతర్నిర్మిత రౌటర్‌గా వాడుతుంది. ఇది పరిపాలనా పని సంక్లిష్టతను డైనమిక్‌గా అంచనా వేసి ఏ Gemini మోడల్‌ను పిలవాలో నిర్ణయిస్తుంది, ప్రాథమిక సామర్థ్యం కోసం Gemini నేటివ్ ఆటో మోడ్‌ను డిఫాల్ట్‌గా ఉంచుతుంది.

దాని కింద, ఒక అంకితమైన Docker బ్రిడ్జ్ నెట్‌వర్క్‌లో (claw_net) పూర్తిగా వేరుచేయబడి, రెండు పని-నిర్దిష్ట వర్కర్లు ఉన్నారు. వర్కర్లు ప్రీపెయిడ్ OpenRouter కనెక్షన్ ద్వారా భారీ పని చేస్తారు. MCP వారి లాగ్‌లను గమనిస్తుంది, వారు విఫలమైతే వారి కాన్ఫిగరేషన్‌లను తిరిగి రాస్తుంది, వారి కంటైనర్‌లను రీస్టార్ట్ చేస్తుంది.

నిర్మాణం

పోర్ట్ ఘర్షణలను, CPU ఓవర్‌హెడ్‌ను తొలగించడానికి Pi 5 ను తుడిచివేయాల్సి వచ్చింది. హార్డ్‌వేర్ ఇప్పుడు పూర్తిగా OpenClaw హోస్ట్.

మొదట నాకు శుభ్రమైన స్లేట్ కావలసి వచ్చింది. ఏ దెయ్యం కంటైనర్ మెమరీని నమలకుండా, నా రూటింగ్ పొరలతో ఘర్షణ పడకుండా ఉండేలా ఇప్పటికే ఉన్న మౌలిక వసతిని పూర్తిగా ప్రక్షాళన చేశాను. తర్వాత వేరుచేసిన నెట్‌వర్క్‌ను (claw_net) ఏర్పాటు చేశాను. Telegram API, OpenRouter కోసం వర్కర్లకు బయటకు వెళ్లే ఇంటర్నెట్ కావాలి, కానీ వారిని వారి సొంత బ్రిడ్జ్ నెట్‌వర్క్‌పై వేరు చేయడం వల్ల వారికి లోపలికి వచ్చే ప్రవేశం లేదని, ఒకరి ట్రాఫిక్‌ను మరొకరు చూడలేరని హామీ.

# Purge all non-essential containers and images
docker stop $(docker ps -aq)
docker rm $(docker ps -aq)
docker system prune -a --volumes -f

# Create the dedicated network for the swarm
docker network create --driver bridge claw_net

సోపానక్రమాన్ని ప్రతిబింబించేలా /opt/openclaw లో ఫైల్ సిస్టమ్‌ను పునర్నిర్మించాను, వర్కర్ల కాన్ఫిగరేషన్ ఫైళ్లపై MCP కి సంపూర్ణ దృశ్యమానతను ఇచ్చాను.

mkdir -p /opt/openclaw/{mcp,workers/worker-01,workers/worker-02}

తర్వాత వేరుచేసిన వర్కర్లను కాన్ఫిగర్ చేశాను. వారి ఆథెంటికేషన్‌ను OpenRouter కు లాక్ చేసి, నేరుగా ఖాతా స్థాయిలోనే కఠినమైన నెలవారీ ఖర్చు పరిమితిని అమలు చేశాను. ఇది బ్యాకెండ్‌లో ఖర్చు మితిమీరడాన్ని అదుపు చేస్తుంది: ఒక లూప్ జరిగినా గరిష్ఠ నష్టం స్పష్టంగా పరిమితమై, అనుకోని 500 డాలర్ల నెలవారీ బిల్లు నుంచి నన్ను కాపాడుతుంది. ఆచరణలో, ఈ పూర్తి సామర్థ్యం గల, రోజువారీ వాడే AI సహాయకులను నడపడానికి నాకు నెలకు వాస్తవికంగా 8 నుంచి 15 డాలర్ల మధ్య ఖర్చవుతుంది. ఏకపక్ష సామర్థ్య పైకప్పులు విధించే బదులు, నేను వారి maxOutputTokens, maxHistoryTurns ను ఆలోచించి ఎంచుకున్న పనితీరు-క్రమాంకన పారామితులుగా ట్యూన్ చేశాను. ఈ విలువలు ప్రతి వర్కర్ పాత్ర స్వభావానికి ప్రత్యేకంగా సరిపోతాయి, అంటే వేగవంతమైన జవాబులు వర్సెస్ సంక్లిష్ట చర్యల కోసం కాంటెక్స్ట్ విండోలను ఆప్టిమైజ్ చేయడం, గణన ఓవర్‌హెడ్‌ను వృథా చేయకుండా వారు పూర్తిగా పనిచేసేలా చూడటం.

# Configure Worker 01
cd /opt/openclaw/workers/worker-01
openclaw onboard --auth-choice apiKey --token-provider openrouter --token "$OPENROUTER_API_KEY" --non-interactive
openclaw config set agents.defaults.model.primary "openrouter/deepseek/deepseek-chat"
openclaw config set agents.defaults.maxOutputTokens 250
openclaw config set agents.defaults.maxHistoryTurns 5

# Configure Worker 02
cd /opt/openclaw/workers/worker-02
openclaw onboard --auth-choice apiKey --token-provider openrouter --token "$OPENROUTER_API_KEY" --non-interactive
openclaw config set agents.defaults.model.primary "openrouter/deepseek/deepseek-chat"
openclaw config set agents.defaults.maxOutputTokens 600
openclaw config set agents.defaults.maxHistoryTurns 8

వర్కర్లను వేరుచేసిన నెట్‌వర్క్‌కు జతచేసి ప్రారంభించాను. వారి వారి కాన్ఫిగరేషన్ డైరెక్టరీలను నేరుగా కంటైనర్‌లలోకి మౌంట్ చేయడం వల్ల, ఒక వర్కర్ తప్పుగా ప్రవర్తించడం మొదలుపెడితే MCP తర్వాత అడుగుపెట్టి Docker సాకెట్ ద్వారా ఆ కాన్ఫిగ్‌లను చదివి, డైనమిక్‌గా తిరిగి రాయగలదు.

docker run -d --name worker-01 \
  --network claw_net \
  -v /opt/openclaw/workers/worker-01:/app/config \
  openclaw/core:latest

docker run -d --name worker-02 \
  --network claw_net \
  -v /opt/openclaw/workers/worker-02:/app/config \
  openclaw/core:latest

చివరగా, మాస్టర్ కంట్రోల్ ప్రోగ్రామ్. MCP కి Google AI ఆధారాలు కావాలి, కానీ అనవసరమైన టోకెన్ దహనాన్ని నివారించడానికి నేను manifest.ai రూటింగ్ స్కిల్‌ను అమలు చేశాను. సబ్-ప్రాసెస్‌లను నేటివ్‌గా పర్యవేక్షించగలిగేలా Docker సాకెట్‌ను, రూట్ /opt/openclaw/workers డైరెక్టరీని దాని కంటైనర్‌లో మౌంట్ చేశాను. రాజ్యం తాళాలున్న ఏకైక కంటైనర్ MCP.

cd /opt/openclaw/mcp
openclaw onboard --auth-choice oauth --token-provider google --non-interactive

# Inject the manifest.ai router skill and set dynamic defaults
openclaw skill add manifest.ai/router
openclaw config set agents.defaults.model.primary "google/gemini-auto"
openclaw config set routing.strategy "manifest-dynamic"

docker run -d --name mcp \
  --network claw_net \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v /opt/openclaw/workers:/supervised_workers \
  -v /opt/openclaw/mcp:/app/config \
  openclaw/core:latest

రాజీలు

LLM-నడిపే కంటైనర్‌లో /var/run/docker.sock ను మౌంట్ చేయడం ప్రొడక్షన్ వాతావరణంలో విపత్కర భద్రతా ప్రమాదం. MCP ప్రాంప్ట్ ఇంజెక్షన్ దాడికి గురైతే, Pi యొక్క Docker డెమన్‌పై దానికి రూట్-స్థాయి నియంత్రణ ఉంటుంది. Pi 5 భౌతికంగా వేరుచేయబడి, పూర్తిగా ఈ ప్రయోగానికే అంకితం కాబట్టి ఈ ప్రమాదాన్ని అంగీకరించాను, కానీ ఇది ఎంటర్‌ప్రైజ్ డిప్లాయ్‌మెంట్‌కు నమూనా కాదు.

అదనంగా, manifest.ai రౌటర్ తెలివైనదే కానీ తప్పులేనిది కాదు. తప్పుగా ఏర్పడిన API పేలోడ్ వల్ల Worker 02 భారీ స్టాక్ ట్రేస్‌ను విసిరినప్పుడు, రౌటర్ దాన్ని సరిగ్గా “సంక్లిష్ట డీబగ్గింగ్ టాస్క్”గా గుర్తించి, తేలికైన Flash వేరియంట్‌కు బదులు అమలును భారీ రీజనింగ్ మోడల్‌కు పెంచింది. ఒక పరిష్కారాన్ని ప్రతిపాదించే ముందు MCP ఎర్రర్ లాగ్ చదవడానికి 40,000 టోకెన్లు మింగేసింది. అది Worker 02 యొక్క అవుట్‌పుట్ స్కీమాను విజయవంతంగా తిరిగి రాసి కంటైనర్‌ను రీస్టార్ట్ చేసింది, కానీ ఆ ఒక్క డీబగ్గింగ్ చర్య ఆటో మోడ్ పొదుపును దాటవేసి, DeepSeek లో Worker 02 యొక్క మొత్తం కార్యాచరణ వారం కన్నా ఎక్కువ ఖర్చయింది.

నేను నేర్చుకున్నది

రూటింగ్ లాజిక్‌ను అమలు చేయడానికి ముందు, Worker 01 నిజంగానే నిశ్శబ్దంగా విఫలమైంది. Telegram నుంచి వచ్చిన తప్పుగా ఏర్పడిన JSON పేలోడ్‌ను అది పార్స్ చేయలేక అక్కడే వేలాడింది, API పదేపదే టైమ్‌అవుట్ అవుతుండగా Pi యొక్క మెమరీ వనరులను నిశ్శబ్దంగా నమిలింది. నేను రెండు రోజులు గమనించలేదు. ఆ నిశ్శబ్దం, అది కలిగించగల వరుస వైఫల్యమే అసలు MCP ని నిర్మించేలా నన్ను నడిపించాయి.

వ్యవస్థ ప్రస్తుతం నేను చేతితో MCP ని వర్కర్లను తనిఖీ చేయమని అడగడంపై ఆధారపడుతుంది, ఇది అర్ధ-చర్య. ఆర్కిటెక్చర్ తార్కిక ముగింపు, ల్యాబ్‌లో నా తదుపరి ప్రాజెక్ట్, నిరంతర హార్ట్‌బీట్ మానిటర్‌ను ఏర్పాటు చేయడం. వర్కర్ల హెల్త్ చెక్‌లను Pi పై ఒక తేలికపాటి లోకల్ వెక్టర్ స్టోర్‌లోకి పైప్ చేయడం ద్వారా, MCP స్వతంత్రంగా పాత క్రాష్ డేటాను విచారించి, వైఫల్యం వరుసగా వ్యాపించడానికి ముందే వర్కర్ల DeepSeek టెంపరేచర్ లేదా టోకెన్ పరిమితులను ముందస్తుగా సర్దుబాటు చేయగలదు.

సంక్లిష్ట AI వ్యవస్థలను నడపడానికి భారీ, మోనోలిథిక్ క్లౌడ్ మౌలిక వసతి అవసరం లేదని ఈ ప్రయోగం నిరూపించింది. ఆర్కిటెక్చర్‌ను ఒకే Raspberry Pi 5 యొక్క భౌతిక పరిమితుల్లోకి, 8–15 డాలర్ల నెలవారీ ఖర్చు పరిమితి యొక్క ఆర్థిక పరిమితిలోకి నెట్టడం వల్ల ఫలితం రాజీపడిన లేదా కట్టడి చేసిన శాండ్‌బాక్స్ కాలేదు. ఆ పరిమితులే వాస్తవానికి మరింత క్రమశిక్షణ గల, అత్యంత సామర్థ్యం గల ఆర్కెస్ట్రేషన్ వ్యవస్థను తీర్చిదిద్దాయి. నేడు ఇవి కేవలం సంకుచిత స్క్రిప్ట్‌లు కాదు; అవి నా వర్క్‌ఫ్లోలను చురుగ్గా నిర్వహించే, నిజంగా ప్రభావవంతమైన, రోజువారీ వాడే AI వ్యక్తిగత సహాయకులు. ల్యాబ్ చివరికి తెలివిగా నడుస్తోంది, సహాయకులు పూర్తిగా విడుదల చేయబడ్డారు, నా బిల్లింగ్ పేజీ చివరికి నీరసంగా ఉంది.