OpenHands AI डेवलपर

Clore.ai पर OpenHands (पहले OpenDevin) डिप्लॉय करें — कोडिंग, डिबगिंग, और GitHub इश्यू समाधान के लिए किफ़ायती GPU क्लाउड सर्वरों पर पूरी तरह स्वायत्त AI सॉफ़्टवेयर इंजीनियर चलाएँ।

अवलोकन

OpenHands (पूर्व OpenDevin) स्वायत्त AI सॉफ़्टवेयर विकास एजेंटों के लिए एक ओपन-सोर्स प्लेटफ़ॉर्म है। 65K+ GitHub स्टार्स के साथ, यह AI को वास्तविक प्रोग्रामिंग कार्य सौंपने के लिए सबसे लोकप्रिय टूल्स में से एक बन गया है — कोड लिखना, बग ठीक करना, GitHub समस्याएँ हल करना, शेल कमांड चलाना, वेब ब्राउज़ करना, और अपनी कोडबेस के साथ एंड-टू-एंड इंटरैक्ट करना।

सामान्य code-completion टूल्स के विपरीत, OpenHands एक एजेंटिक लूप: यह एक कार्य प्राप्त करता है, योजना बनाता है, कोड लिखता है, उसे निष्पादित करता है, आउटपुट देखता है, और पुनरावृत्ति करता है — वह भी बिना किसी मानवीय हस्तक्षेप के। यह OpenAI, Anthropic Claude, Google Gemini, और Ollama या vLLM के माध्यम से स्थानीय रूप से होस्ट किए गए मॉडलों सहित दर्जनों LLM बैकएंड्स का समर्थन करता है।

OpenHands के लिए Clore.ai क्यों?

OpenHands स्वयं CPU-आधारित है और GPU की आवश्यकता नहीं होती
हालाँकि, इसे एक के साथ जोड़ना स्थानीय LLM (Ollama, vLLM) को उसी सर्वर पर रखने से API लागत और विलंबता समाप्त हो जाती है
Clore.ai के किफ़ायती GPU सर्वर आपको OpenHands और एक स्थानीय मॉडल दोनों चलाने देते हैं, वह भी मात्र $0.20–$0.35/घंटा
आपको स्थायी वर्कस्पेस स्टोरेज, Docker-in-Docker सपोर्ट, और पूर्ण रूट एक्सेस मिलता है
लंबे समय तक चलने वाले स्वायत्त कार्यों के लिए आदर्श, जो cloud LLM APIs के माध्यम से महंगे पड़ेंगे

Clore.ai पर सामान्य उपयोग के मामले:

एक spec या issue विवरण से स्वायत्त कोड जेनरेशन
बड़े codebases का bulk refactoring
100% offline agentic development के लिए OpenHands + Ollama को साथ चलाना
API लागत के बिना CI/CD कार्य स्वचालन

आवश्यकताएँ

OpenHands को Docker socket access की आवश्यकता होती है और यह आंतरिक रूप से एक sandboxed runtime container चलाता है। निम्न तालिका Clore.ai पर अनुशंसित कॉन्फ़िगरेशन को कवर करती है:

कॉन्फ़िगरेशन

GPU

VRAM

RAM

स्टोरेज

अनुमानित कीमत

केवल API (कोई स्थानीय LLM नहीं)

कोई भी / केवल CPU

उपलब्ध नहीं

8 GB

20 GB

~$0.05–0.10/घंटा

+ Ollama (Llama 3.1 8B)

RTX 3090

24 GB

16 GB

40 GB

$0.07–0.21/hr

+ Ollama (Qwen2.5 32B)

RTX 4090

24 GB

32 GB

60 GB

$0.14–0.42/hr

+ vLLM (Llama 3.1 70B)

A100 80GB

80 GB

64 GB

100 GB

bare metal

+ vLLM (Llama 3.3 70B INT4)

RTX 4090

24 GB

32 GB

80 GB

$0.14–0.42/hr

ध्यान दें: यदि आप केवल OpenAI/Anthropic/Gemini APIs का उपयोग करते हैं, तो ≥8 GB RAM वाला कोई भी सर्वर काम करेगा। GPU केवल तब चाहिए जब आप उसी मशीन पर स्थानीय LLM चलाना चाहें। अधिक जानकारी के लिए देखें GPU तुलना गाइड ।

Clore.ai सर्वर पर सॉफ़्टवेयर आवश्यकताएँ:

Docker Engine (सभी Clore.ai इमेजेज़ पर पहले से इंस्टॉल)
NVIDIA Container Toolkit (GPU images पर पहले से इंस्टॉल)
Docker socket यहां उपलब्ध: /var/run/docker.sock
GHCR images खींचने के लिए आउटबाउंड इंटरनेट एक्सेस

त्वरित शुरुआत

चरण 1: एक Clore.ai सर्वर चुनें और कनेक्ट करें

में Clore.ai मार्केटप्लेस, सर्वरों को इनके आधार पर फ़िल्टर करें:

RAM ≥ 16 GB (स्थानीय LLM संयोजन के लिए)
Docker: ✓ सक्षम
यदि आप स्थानीय मॉडल का उपयोग कर रहे हैं, तो अपनी पसंद का GPU चुनें

सर्वर प्राविजन हो जाने के बाद SSH के माध्यम से कनेक्ट करें:

ssh root@<server-ip> -p <port>

चरण 2: सत्यापित करें कि Docker चल रहा है

docker info
ls -la /var/run/docker.sock

दोनों कमांड सफल होने चाहिए। यदि Docker socket गायब है, तो Clore.ai support से संपर्क करें या कोई अलग image चुनें।

चरण 3: OpenHands को pull और run करें

# वर्कस्पेस डायरेक्टरी सेट करें
export WORKSPACE_BASE=$(pwd)/workspace
mkdir -p $WORKSPACE_BASE

# OpenHands चलाएँ (GHCR से नवीनतम 0.38 image pull करता है)
docker run -it --pull=always \\
  -e SANDBOX_RUNTIME_CONTAINER_IMAGE=ghcr.io/all-hands-ai/runtime:0.38-nikolaik \\
  -e SANDBOX_USER_ID=$(id -u) \\
  -e WORKSPACE_MOUNT_PATH=$WORKSPACE_BASE \\
  -v $WORKSPACE_BASE:/opt/workspace_base \\
  -v /var/run/docker.sock:/var/run/docker.sock \\
  -p 3000:3000 \
  --add-host host.docker.internal:host-gateway \
  ghcr.io/all-hands-ai/openhands:0.38

चरण 4: Web UI तक पहुँचें

UI यहां उपलब्ध है http://<server-ip>:3000

Clore.ai पोर्ट फ़ॉरवर्डिंग: Clore.ai dashboard में, सुनिश्चित करें कि पोर्ट 3000 आपकी सर्वर कॉन्फ़िगरेशन में फ़ॉरवर्ड/एक्सपोज़ किया गया है। कुछ templates बाहरी पोर्ट्स को प्रतिबंधित करते हैं — अपने server details के "Ports" सेक्शन की जाँच करें।

पहली बार लॉन्च करने पर, OpenHands आपसे एक LLM provider कॉन्फ़िगर करने के लिए कहेगा।

चरण 5: अपना LLM कॉन्फ़िगर करें

वेब UI settings में:

Provider: OpenAI, Anthropic, Google, या Custom चुनें
API Key: अपनी API key दर्ज करें
मॉडल: उदा., gpt-4o, claude-3-5-sonnet-20241022या ollama/llama3.1

स्थानीय Ollama के लिए (नीचे GPU Acceleration सेक्शन देखें), उपयोग करें:

Provider: ollama
Base URL: http://host.docker.internal:11434
मॉडल: ollama/llama3.1:8b

कॉन्फ़िगरेशन

पर्यावरण चर

OpenHands को पूरी तरह से environment variables के माध्यम से कॉन्फ़िगर किया जा सकता है जिन्हें पास किया जाता है docker run:

docker run -it --pull=always \\
  -e SANDBOX_RUNTIME_CONTAINER_IMAGE=ghcr.io/all-hands-ai/runtime:0.38-nikolaik \\
  -e SANDBOX_USER_ID=$(id -u) \\
  -e WORKSPACE_MOUNT_PATH=$WORKSPACE_BASE \\
  -e LLM_MODEL=claude-3-5-sonnet-20241022 \\
  -e LLM_API_KEY=sk-ant-... \\
  -e LLM_BASE_URL="" \\
  -e SANDBOX_TIMEOUT=120 \\
  -e MAX_ITERATIONS=100 \\
  -v $WORKSPACE_BASE:/opt/workspace_base \\
  -v /var/run/docker.sock:/var/run/docker.sock \\
  -p 3000:3000 \
  --add-host host.docker.internal:host-gateway \
  ghcr.io/all-hands-ai/openhands:0.38

वेरिएबल

विवरण

डिफ़ॉल्ट

LLM_MODEL

मॉडल पहचानकर्ता (उदा. gpt-4o, claude-3-5-sonnet-20241022)

UI में सेट करें

LLM_API_KEY

LLM provider के लिए API key

UI में सेट करें

LLM_BASE_URL

कस्टम base URL (Ollama, vLLM, LiteLLM के लिए)

provider डिफ़ॉल्ट

SANDBOX_TIMEOUT

सेकंड में agent sandbox timeout

120

MAX_ITERATIONS

प्रति कार्य अधिकतम agentic loop iterations

100

SANDBOX_USER_ID

sandbox को चलाने के लिए UID (उपयोग करें $(id -u))

0

LOG_ALL_EVENTS

विस्तृत इवेंट लॉगिंग सक्षम करें (true/false)

false

स्थायी कॉन्फ़िगरेशन फ़ाइल

आप config directory माउंट करके सेटिंग्स को स्थायी बना सकते हैं:

mkdir -p /opt/openhands/config

docker run -it --pull=always \\
  -e SANDBOX_RUNTIME_CONTAINER_IMAGE=ghcr.io/all-hands-ai/runtime:0.38-nikolaik \\
  -e SANDBOX_USER_ID=$(id -u) \\
  -e WORKSPACE_MOUNT_PATH=$WORKSPACE_BASE \\
  -v $WORKSPACE_BASE:/opt/workspace_base \\
  -v /var/run/docker.sock:/var/run/docker.sock \\
  -v /opt/openhands/config:/app/config \\
  -p 3000:3000 \
  --add-host host.docker.internal:host-gateway \
  ghcr.io/all-hands-ai/openhands:0.38

बैकग्राउंड में चलाना (Detached Mode)

Clore.ai पर लंबे चलने वाले sessions के लिए:

export WORKSPACE_BASE=/opt/workspace
mkdir -p $WORKSPACE_BASE

docker run -d \\
  --name openhands \\
  --restart unless-stopped \\
  --pull=always \\
  -e SANDBOX_RUNTIME_CONTAINER_IMAGE=ghcr.io/all-hands-ai/runtime:0.38-nikolaik \\
  -e SANDBOX_USER_ID=0 \\
  -e WORKSPACE_MOUNT_PATH=$WORKSPACE_BASE \\
  -e LLM_MODEL=claude-3-5-sonnet-20241022 \\
  -e LLM_API_KEY=your_api_key_here \\
  -v $WORKSPACE_BASE:/opt/workspace_base \\
  -v /var/run/docker.sock:/var/run/docker.sock \\
  -p 3000:3000 \
  --add-host host.docker.internal:host-gateway \
  ghcr.io/all-hands-ai/openhands:0.38

# लॉग देखें
docker logs -f openhands

GPU एक्सेलेरेशन (लोकल LLM इंटीग्रेशन)

हालाँकि OpenHands स्वयं GPU का उपयोग नहीं करता, इसे एक के साथ जोड़ना स्थानीय LLM जो Clore.ai के GPU पर चल रहा हो, आपको एक शक्तिशाली, किफ़ायती, API-रहित स्वायत्त agent देता है।

विकल्प A: OpenHands + Ollama (शुरुआती लोगों के लिए अनुशंसित)

पहले Ollama चलाएँ, फिर OpenHands को उसकी ओर इंगित करें:

# 1. Ollama शुरू करें (पूर्ण विवरण के लिए Ollama guide देखें)
docker run -d \\
  --name ollama \
  --gpus all \\
  -p 11434:11434 \
  -v ollama-data:/root/.ollama \\
  ollama/ollama:latest

# 2. कोडिंग के लिए अनुकूलित मॉडल pull करें
docker exec ollama ollama pull qwen2.5-coder:7b
# या अधिक ताकत के लिए:
docker exec ollama ollama pull llama3.1:8b
docker exec ollama ollama pull deepseek-coder-v2:16b

# 3. OpenHands को Ollama की ओर इंगित करते हुए शुरू करें
export WORKSPACE_BASE=/opt/workspace
mkdir -p $WORKSPACE_BASE

docker run -d \\
  --name openhands \\
  -e SANDBOX_RUNTIME_CONTAINER_IMAGE=ghcr.io/all-hands-ai/runtime:0.38-nikolaik \\
  -e SANDBOX_USER_ID=0 \\
  -e WORKSPACE_MOUNT_PATH=$WORKSPACE_BASE \\
  -e LLM_MODEL=ollama/qwen2.5-coder:7b \\
  -e LLM_BASE_URL=http://host.docker.internal:11434 \\
  -e LLM_API_KEY=ollama \\
  -v $WORKSPACE_BASE:/opt/workspace_base \\
  -v /var/run/docker.sock:/var/run/docker.sock \\
  -p 3000:3000 \
  --add-host host.docker.internal:host-gateway \
  ghcr.io/all-hands-ai/openhands:0.38

पूरा देखें Ollama गाइड मॉडल चयन, प्रदर्शन ट्यूनिंग, और GPU कॉन्फ़िगरेशन के लिए।

विकल्प B: OpenHands + vLLM (उच्च प्रदर्शन)

बड़े मॉडलों के साथ अधिकतम throughput के लिए:

# 1. एक coding मॉडल के साथ vLLM शुरू करें
docker run -d \\
  --name vllm \\
  --gpus all \\
  -p 8000:8000 \
  --ipc=host \
  vllm/vllm-openai:latest \
  --model Qwen/Qwen2.5-Coder-32B-Instruct \
  --max-model-len 16384 \
  --gpu-memory-utilization 0.92

# मॉडल के लोड होने तक प्रतीक्षा करें (~2-5 मिनट)
docker logs -f vllm | grep "Application startup"

# 2. vLLM backend के साथ OpenHands शुरू करें
docker run -d \\
  --name openhands \\
  -e SANDBOX_RUNTIME_CONTAINER_IMAGE=ghcr.io/all-hands-ai/runtime:0.38-nikolaik \\
  -e SANDBOX_USER_ID=0 \\
  -e WORKSPACE_MOUNT_PATH=/opt/workspace \\
  -e LLM_MODEL=openai/Qwen/Qwen2.5-Coder-32B-Instruct \\
  -e LLM_BASE_URL=http://host.docker.internal:8000/v1 \\
  -e LLM_API_KEY=none \\
  -v /opt/workspace:/opt/workspace_base \\
  -v /var/run/docker.sock:/var/run/docker.sock \\
  -p 3000:3000 \
  --add-host host.docker.internal:host-gateway \
  ghcr.io/all-hands-ai/openhands:0.38

देखें vLLM गाइड पूर्ण setup, quantization options, और multi-GPU configurations के लिए।

कोडिंग के लिए अनुशंसित स्थानीय मॉडल

मॉडल

आकार

न्यूनतम VRAM

गुणवत्ता

qwen2.5-coder:7b

8 GB

★★★☆☆

deepseek-coder-v2:16b

16B

12 GB

★★★★☆

qwen2.5-coder:32b

32B

24 GB

★★★★☆

llama3.1:70b

70B

48 GB

★★★★★

टिप्स और सर्वोत्तम अभ्यास

1. Workspace Mounts का बुद्धिमानी से उपयोग करें

OpenHands को आपकी फ़ाइलें सीधे संपादित करने देने के लिए अपने वास्तविक project directory को workspace के रूप में माउंट करें:

export WORKSPACE_BASE=/opt/my-project
git clone https://github.com/your/repo $WORKSPACE_BASE

2. सर्वोत्तम परिणामों के लिए Task Prompting

OpenHands विशिष्ट, क्रियान्वयन योग्य prompts के साथ सबसे अच्छा काम करता है:

✅ अच्छा: "src/auth/login.py में authentication bug ठीक करें जहाँ JWT tokens 
         तुरंत expire हो जाते हैं। समस्या token expiration calculation में है।"

❌ खराब: "bug ठीक करें"

3. संसाधन उपयोग की निगरानी करें

# GPU और memory usage देखें
watch -n 2 'nvidia-smi && docker stats --no-stream'

4. Iteration Limits सेट करें

अनियंत्रित agents को बहुत अधिक API tokens खर्च करने से रोकें:

-e MAX_ITERATIONS=50  # प्रति कार्य 50 steps तक सीमित करें

5. GitHub Integration

OpenHands GitHub issues को सीधे हल कर सकता है। UI में कॉन्फ़िगर करें:

GitHub Token: आपका personal access token जिसके साथ repo scope
OpenHands repo clone करेगा, issue ठीक करेगा, और एक PR बनाएगा

6. Cost Estimation

API-आधारित LLMs के लिए, प्रति कार्य लागत का अनुमान लगाएँ:

सरल bug fix: ~$0.05–0.15 (Claude Haiku/GPT-4o-mini)
जटिल फीचर: ~$0.50–2.00 (Claude Sonnet/GPT-4o)
100+ tasks/day के लिए, Clore.ai पर स्थानीय LLM अपनी लागत वसूल कर लेता है

समस्या निवारण

Docker Socket अनुमति अस्वीकृत

# त्रुटि: Docker daemon से कनेक्ट करने का प्रयास करते समय अनुमति अस्वीकृत
# ठीक करें: सुनिश्चित करें कि socket accessible है
ls -la /var/run/docker.sock
# ऐसा दिखना चाहिए: srw-rw---- 1 root docker ...

# आवश्यकता होने पर अपने user को docker group में जोड़ें
usermod -aG docker $USER
# फिर shell restart करें या उपयोग करें: newgrp docker

Sandbox Container शुरू करने में विफल

# जांचें कि runtime image accessible है या नहीं
docker pull ghcr.io/all-hands-ai/runtime:0.38-nikolaik

# GHCR rate limits जांचें (प्रमाणीकरण की आवश्यकता हो सकती है)
docker login ghcr.io

Port 3000 सुलभ नहीं है

# सत्यापित करें कि container चल रहा है और port bind है
docker ps | grep openhands
docker port openhands

# Clore.ai firewall जांचें — सुनिश्चित करें कि port 3000 आपकी port mapping में है
# Clore.ai dashboard में: Server → Ports → Add 3000:3000

Ollama के साथ LLM कनेक्शन त्रुटियाँ

# जांचें कि OpenHands container से Ollama पहुंच योग्य है
docker exec openhands curl http://host.docker.internal:11434/api/tags

# यदि यह विफल होता है, तो सत्यापित करें कि docker run में --add-host flag शामिल था
# साथ ही जांचें कि Ollama container चल रहा है:
docker ps | grep ollama
docker logs ollama | tail -20

Agent अनंत लूप में चला जाता है

# अधिकतम iterations कम करें
docker stop openhands
docker run ... -e MAX_ITERATIONS=30 ...

# या timeout सेट करें
-e SANDBOX_TIMEOUT=60

मेमोरी समाप्त (OOM)

# memory usage जांचें
free -h
docker stats

# यदि स्थानीय LLM चला रहे हैं, तो छोटा मॉडल आज़माएँ
docker exec ollama ollama pull qwen2.5-coder:3b

# या quantized संस्करण उपयोग करें (कम VRAM)
docker exec ollama ollama pull llama3.1:8b-instruct-q4_K_M

अधिक पढ़ें

OpenHands GitHub Repository — स्रोत कोड, issues, और releases
OpenHands Documentation — LLM configuration सहित आधिकारिक docs
Clore.ai पर Ollama — मुफ्त agent inference के लिए स्थानीय LLMs चलाएँ
Clore.ai पर vLLM — उच्च-प्रदर्शन स्थानीय LLM serving
GPU तुलना गाइड — अपने workload के लिए सही GPU चुनें
OpenHands Discord — सामुदायिक सहायता और मॉडल अनुशंसाएँ
SWE-bench Leaderboard — वास्तविक GitHub issues पर agent प्रदर्शन की तुलना करें

पिछलाCrewAI मल्टी-एजेंट फ़्रेमवर्क

अगलाLangflow विज़ुअल AI बिल्डर

अंतिम अपडेट 1 माह पहले

क्या यह उपयोगी था?