How do I install and start using AI OpenHands quickly?

Use the official quickstart to install prerequisites, plug in a supported LLM (cloud or local), and launch the UI to connect your repository. The "Start Building" docs provide step-by-step instructions with setup tips.

Can I run OpenHands with a local LLM instead of a cloud model?

Yes. Follow the Local LLMs guide to configure a local model backend and adjust context settings. This is ideal for privacy-sensitive projects or avoiding API costs.

What’s the best way to prompt OpenHands for coding tasks?

Write prompts like concise tickets: define the goal, reference specific files, set boundaries, and include acceptance criteria. Ask it to create or run tests to validate progress.

Is AI OpenHands safe to use on production code?

Treat it like a junior developer: use branch protections, code review, and CI to validate changes. Add guardrails for commands and keep secrets out of prompts.

How does OpenHands compare to a traditional code assistant?

Unlike chat-only tools, OpenHands can run commands, edit files, and iterate autonomously within your repo. It’s built for end-to-end tasks like features, debugging, and tests.

AI OpenHands નો ઉપયોગ કેવી રીતે કરવો: સેટઅપ, પ્રોમ્પ્ટ્સ અને વાસ્તવિક-દુનિયાના વર્કફ્લો માટે એક વ્યવહારુ માર્ગદર્શિકા

જો તમે ક્યારેય ઇચ્છતા હોવ કે એક સક્ષમ ડેવલપર તમારી સાથે 24/7 જોડી-પ્રોગ્રામ કરી શકે, તો AI OpenHands આશ્ચર્યજનક રીતે નજીક આવે છે. તે એક ઓપન-સોર્સ "AI એન્જિનિયર" છે જે તમારી રેપો વાંચી શકે છે, કોડ લખી શકે છે, ટર્મિનલ્સ ચલાવી શકે છે, ડોક્સ બ્રાઉઝ કરી શકે છે અને પુનરાવર્તન કરી શકે છે—એક જુનિયર ડેવની જેમ જે ઝડપથી શીખે છે અને અથાક મહેનત કરે છે. પરંતુ પાવર ત્યારે જ ક્લિક થાય છે જ્યારે તમે તેને યોગ્ય રીતે સેટ કરો અને તેને કેવી રીતે ચલાવવું તે શીખો.

આ માર્ગદર્શિકા તમને AI OpenHands નો ઉપયોગ કેવી રીતે કરવો તે સ્ટેપ-બાય-સ્ટેપ સમજાવે છે—ઇન્સ્ટોલથી લઈને એડવાન્સ્ડ વર્કફ્લો સુધી—જેથી તમે આત્મવિશ્વાસ સાથે ઝડપથી શિપિંગ કરી શકો.

અમે શું આવરીશું:

ઇન્સ્ટોલેશન વિકલ્પો અને ઝડપી શરૂઆત

OpenHands ને સ્થાનિક રીતે અથવા ક્લાઉડ મોડેલ્સ સાથે ચલાવવું

પ્રોમ્પ્ટ્સ, રેપો અને કાર્યો માટે શ્રેષ્ઠ પ્રથાઓ

ફીચર વર્ક, ડિબગીંગ, ટેસ્ટ અને ડોક્સ માટે સાબિત વર્કફ્લો

ગાર્ડરેલ્સ, પ્રાઇવસી અને સહયોગ

નોંધનીય બાબત: OpenHands એ ઓલ હેન્ડ્સ ટીમ અને સમુદાય દ્વારા સક્રિયપણે વિકસાવવામાં આવી રહ્યું છે. સત્તાવાર ડોક્સ એ વર્તમાન સૂચનાઓ અને ટીપ્સ માટે તમારો ઉત્તર સ્ટાર છે. તમે પ્રેક્ટિશનર્સ પાસેથી હેન્ડ્સ-ઓન ઇન્સ્ટોલ માર્ગદર્શિકાઓ પણ અનુસરી શકો છો જેમણે સ્થાનિક અને VM સેટઅપ્સનું દસ્તાવેજીકરણ કર્યું છે. સ્થાનિક મોડેલ્સ સાથે ચલાવવા માટે, ડોક્સમાં ચોક્કસ માર્ગદર્શન પણ શામેલ છે.

AI OpenHands શું છે—અને તેનો ઉપયોગ શા માટે કરવો?

AI OpenHands ને કીબોર્ડ સાથેના AI ટીમના સભ્ય તરીકે વિચારો. ચેટ-ઓન્લી સહાયકોથી વિપરીત, OpenHands આ કરી શકે છે:

પ્રોજેક્ટ ફાઇલો ખોલો અને વાંચો

આદેશો, પરીક્ષણો અને લિંટર્સ ચલાવવા માટે ટર્મિનલનો ઉપયોગ કરો

ફાઇલો અને ડિરેક્ટરીઓમાં કોડ સંપાદિત કરો

વેબ બ્રાઉઝ કરો (રૂપરેખાંકન પર આધાર રાખીને)

સ્ટેપ-બાય-સ્ટેપ યોજનાઓ પ્રસ્તાવિત કરો અને લાગુ કરો

આ તેને ફીચર્સ લાગુ કરવા, બગ્સને ઠીક કરવા, પરીક્ષણો લખવા, ડોક્સ બનાવવા, રિફેક્ટરિંગ કરવા અને કોડબેઝને આધુનિક બનાવવા જેવા કાર્યો માટે આદર્શ બનાવે છે. પ્રોમ્પ્ટ્સ અને કોપી/પેસ્ટને બદલે, તમે OpenHands ને એક ધ્યેય આપો અને તેને પુનરાવર્તન કરવા દો, અને તમે તેની મૂવ્સનું નિરીક્ષણ કરો.

ઝડપી શરૂઆત: OpenHands નો ઉપયોગ કરવાની સૌથી ઝડપી રીત

શરૂ કરવા માટે ઘણી રીતો છે. તમારી પસંદગી એના પર નિર્ભર કરે છે કે તમે ક્લાઉડ LLM નો ઉપયોગ કરવા માંગો છો કે બધું સ્થાનિક રીતે ચલાવવા માંગો છો.

વિકલ્પ A: ક્લાઉડ LLM નો ઉપયોગ કરો (સૌથી સરળ)

એપ્લિકેશનને ઇન્સ્ટોલ અને ચલાવવા માટે સત્તાવાર "સ્ટાર્ટ બિલ્ડિંગ" અને "ગેટિંગ સ્ટાર્ટેડ" ડોક્સને અનુસરો. તમે સામાન્ય રીતે આ કરશો:

પૂર્વજરૂરીયાતો ઇન્સ્ટોલ કરો (Docker, Node, Python, Git પાથના આધારે)

સપોર્ટેડ ક્લાઉડ મોડેલ માટે API કી પ્રદાન કરો (દા.ત., OpenAI, Anthropic, અથવા પ્રોજેક્ટ તે સમયે સપોર્ટ કરે છે તે અન્ય)

OpenHands ઇન્ટરફેસ લોંચ કરો અને તમારી રિપોઝીટરીને કનેક્ટ કરો

આ પાથ તમને ઓછામાં ઓછા કમ્પ્યુટ ઓવરહેડ સાથે ઝડપથી ઉત્પાદક બનાવે છે.

વિકલ્પ B: સ્થાનિક LLM સાથે OpenHands ચલાવો

જો તમે કોડ અને પ્રોમ્પ્ટ્સને ક્લાઉડથી દૂર રાખવાનું પસંદ કરો છો અથવા API ખર્ચ ટાળવા માંગો છો, તો સત્તાવાર ડોક્સમાં સ્થાનિક LLMs માર્ગદર્શિકાનો ઉપયોગ કરો.

આ કરવાની અપેક્ષા રાખો:

સુસંગત સ્થાનિક મોડેલ સેટ કરો (Ollama અથવા તે સમયે સપોર્ટેડ અન્ય બેકએન્ડ દ્વારા)

મોડેલ એન્ડપોઇન્ટ્સ અને સંદર્ભ મર્યાદાઓને રૂપરેખાંકિત કરો

ખાતરી કરો કે તમારા મશીનમાં પૂરતી VRAM/CPU અને ડિસ્ક જગ્યા છે

વિકલ્પ C: VM પર જમાવો

જો તમને સમર્પિત પર્યાવરણની જરૂર હોય, તો પ્રેક્ટિશનર્સે દસ્તાવેજીકરણ કર્યું છે કે VM પર OpenHands કેવી રીતે સ્પિન અપ કરવું અને મિનિટોમાં એપ્લિકેશન બનાવવી. આ ટીમો માટે ઉપયોગી છે જે સ્થિર, શેર કરેલ AI એન્જિનિયર ઇન્સ્ટન્સ ઇચ્છે છે.

પ્રથમ રન: પ્રોજેક્ટ સેટઅપ અને ટાસ્ક ફ્રેમિંગ

OpenHands ત્યારે ચમકે છે જ્યારે તે તમારો કોડ જોઈ શકે છે. આનાથી શરૂઆત કરો:

તમે જેના પર કામ કરવા માંગો છો તે રિપોઝીટરી ખોલો.

પ્રોજેક્ટ ચલાવો અથવા ઇન્ડેક્સ કરો જેથી OpenHands સ્ટ્રક્ચરને મેપ કરી શકે.

તેને મર્યાદાઓ સાથે સ્પષ્ટ ધ્યેય આપો.

સારા ટાસ્ક ફ્રેમિંગનું ઉદાહરણ:

"{a2}auth{/a2} સેવા માં ટોકન આધારિત ઈમેલ લીંક નો ઉપયોગ કરીને યુઝર પાસવર્ડ રીસેટ ઉમેરો. હાલના {a4}mailer{/a4} મોડ્યુલ નો ઉપયોગ કરો. ટોકન જનરેશન અને એક્સપાયરી માટે યુનિટ ટેસ્ટ ઉમેરો. યુઝર ડેટા સ્કીમા બદલશો નહીં."

આ શા માટે કામ કરે છે:

તે ઘટક, અવકાશ, અવલંબન અને સીમાઓનું નામ આપે છે. તમે જેટલા સ્પષ્ટ હશો, OpenHands તેટલી સારી યોજના બનાવે છે અને અમલ કરે છે.

OpenHands માટે અસરકારક પ્રોમ્પ્ટ્સ કેવી રીતે લખવા

પ્રોમ્પ્ટ્સને સંક્ષિપ્ત ટિકિટ તરીકે વિચારો. શ્રેષ્ઠ લોકો:

પરિણામ વ્યાખ્યાયિત કરો: "Y મર્યાદાઓ સાથે X લાગુ કરો"

ફાઇલો, મોડ્યુલો અથવા પરીક્ષણોનો સંદર્ભ લો: "{a2}auth/routes.py{/a2} અને {a4}tests/test_auth.py{/a4} જુઓ"

મર્યાદાઓ જણાવો: "કોઈ DB સ્કીમા ફેરફારો નહીં; હાલના ઇન્ટરફેસ રાખો"

સ્વીકૃતિ માપદંડ શામેલ કરો: "પરીક્ષણો પાસ થવા જોઈએ: {a2}pytest -k password_reset{/a2}"

ટેમ્પલેટ જેનો તમે ફરીથી ઉપયોગ કરી શકો છો:

{a1}ધ્યેય: <તમે શું બનાવવા અથવા ઠીક કરવા માંગો છો>{/a1}{a2}સંદર્ભ: <સંબંધિત ફાઇલો, જાણીતી મર્યાદાઓ, બાહ્ય સેવાઓ>{/a2}{a3}સ્વીકૃતિ: <શું પાસિંગ જેવું લાગે છે: પરીક્ષણો, એન્ડપોઇન્ટ્સ, મેટ્રિક્સ>{/a3}{a4}સીમાઓ: <શું બદલવું નહીં અથવા ટાળવા માટેના અભિગમો>{/a4}{a5}સાધનો: <આદેશો તે ચલાવી શકે છે, સ્ક્રિપ્ટ્સ અથવા ડેટા સ્ત્રોતો>{/a5}

મુખ્ય વર્કફ્લો: યોજના → અમલ → ચકાસો → સુધારો

OpenHands સામાન્ય રીતે મલ્ટી-સ્ટેપ પ્લાન પ્રસ્તાવિત કરે છે. તેને કેવી રીતે માર્ગદર્શન આપવું તે અહીં છે:

તેની યોજનાને વહેલી તકે મંજૂર કરો અથવા સમાયોજિત કરો. નિષ્ફળતાઓને બેઝલાઇન કરવા માટે તેને પહેલા પરીક્ષણો ચલાવવા માટે દબાણ કરો.

સફળતાને વ્યાખ્યાયિત કરવા માટે તેને પરીક્ષણ બનાવવા અથવા અપડેટ કરવા માટે કહો, પછી કોડ લાગુ કરો.

વારંવાર ટેસ્ટ સ્યુટ અને લિંટર્સ ચલાવો.

જો તે અટકે છે, તો વધુ સંદર્ભ ઉમેરો: ફાઇલનામો, સ્ટેક ટ્રેસ અથવા લોગ.

પ્રો ટીપ: મોનોલિથિક સંપાદનોને બદલે નાના PR-કદના ફેરફારોને પ્રોત્સાહિત કરો. આ સમીક્ષા અને રોલબેક કરવામાં મદદ કરે છે.

ઉદાહરણ વર્કફ્લો જે તમે કોપી કરી શકો છો

1) ફીચર અમલીકરણ

પ્રોમ્પ્ટ: "{a2}orders{/a2} પૃષ્ઠમાં CSV નિકાસ ઉમેરો. સર્વર-સાઇડ પૃષ્ઠ ક્રમાંકનનો ઉપયોગ કરો, {a4}text/csv{/a4} દ્વારા પરિણામો સ્ટ્રીમ કરો. {a8}OrdersTable.jsx{/a8} માં {a6}નિકાસ કરો{/a6} બટન અને {a10}routes/orders.ts{/a10} માં એન્ડપોઇન્ટ ઉમેરો. પૃષ્ઠ ક્રમાંકન અને હેડરો માટે પરીક્ષણો શામેલ કરો."

OpenHands પગલાં:

રેપો સ્કેન કરે છે; યોજનાનો ડ્રાફ્ટ તૈયાર કરે છે

એન્ડપોઇન્ટ અને ક્લાયન્ટ બટન ઉમેરે છે

પરીક્ષણો લખે છે અને તેમને ચલાવે છે

નિષ્ફળતા પર પુનરાવર્તન કરે છે

તમે દેખરેખ કરો, ફેરફારોને મંજૂરી આપો અને એકવાર લીલો થઈ જાય પછી મર્જ કરો.

2) નિષ્ફળ બિલ્ડને ડિબગ કરવું

પ્રોમ્પ્ટ: "CI Node 20 પર નિષ્ફળ થઈ રહ્યું છે. {a2}build.mjs{/a2} માં ESM/CJS આયાત ભૂલોને ઠીક કરો. હાલના રોલઅપ પ્લગિન્સ રાખો; CI પાસ કરવા માટે રૂપરેખાંકન અને કોડ અપડેટ કરો."

લોગ પ્રદાન કરો અથવા CI આર્ટિફેક્ટ્સની લિંક આપો.

OpenHands ને સ્થાનિક રીતે નકલ કરવા ({a2}npm run build{/a2}) અને ન્યૂનતમ તફાવતો પ્રસ્તાવિત કરવા માટે કહો.

3) ટેસ્ટ કવરેજ અને સખ્તાઇ

પ્રોમ્પ્ટ: "{a2}payments/service.py{/a2} માટે કવરેજ 62% થી વધારીને 85% + કરો. {a4}retry_charge{/a4}, {a6}refund{/a6}, {a8}webhook_signature{/a8} માટે યુનિટ ટેસ્ટ ઉમેરો. જ્યાં સુધી પરીક્ષણ બગને ઉજાગર ન કરે ત્યાં સુધી વ્યવસાયિક તર્કને સંશોધિત કરશો નહીં."

OpenHands ને પરીક્ષણો જનરેટ કરવા, તેમને ચલાવવા અને સુધારવા દો.

4) ડોક્સ અને ડેવલપર અનુભવ

પ્રોમ્પ્ટ: "આ રેપો માટે {a2}CONTRIBUTING.md{/a2} અને {a4}DEVELOPMENT.md{/a4} બનાવો. પર્યાવરણ સેટઅપ, સ્ક્રિપ્ટ્સ, ટેસ્ટ આદેશો અને PR માર્ગદર્શિકાઓ શામેલ કરો."

આદેશોને વાસ્તવમાં ચલાવીને ચકાસવા માટે કહો.

ગાર્ડરેલ્સ: OpenHands ને મદદરૂપ અને સલામત રાખો

ડિરેક્ટરી અવકાશ: આકસ્મિક સંપાદનોને ટાળવા માટે તેને ચોક્કસ રેપો અથવા ડિરેક્ટરી પર નિર્દેશ કરો.

ફાઇલ સુરક્ષા: રૂપરેખાંકન ફાઇલો અથવા જટિલ ઇન્ફ્રાને શક્ય હોય ત્યાં સુધી ફક્ત વાંચવા માટે માર્ક કરો.

આદેશ ઓડિટિંગ: વિનાશક આદેશો માટે મંજૂરી જરૂરી છે (દા.ત., {a2}rm -rf{/a2}, ડેટાબેઝ રીસેટ્સ).

સિક્રેટ્સ સ્વચ્છતા: પ્રોમ્પ્ટ્સમાં ક્યારેય API કી પેસ્ટ કરશો નહીં. પર્યાવરણ ચલો અને માસ્ક્ડ લોગનો ઉપયોગ કરો.

નેટવર્ક એક્સેસ: જો બ્રાઉઝિંગ સક્ષમ કરેલ હોય, તો તેને સેન્ડબોક્સ કરો અને આઉટબાઉન્ડ કોલ્સ લોગ કરો.

સ્થાનિક વિરુદ્ધ ક્લાઉડ મોડેલ્સ: તમારા માટે યોગ્ય શું છે તે પસંદ કરવું

ક્લાઉડ LLMs

ગુણ: મજબૂત તર્ક/કોડિંગ, ન્યૂનતમ સેટઅપ, ઝડપી પુનરાવર્તન

વિપક્ષ: ચાલુ ખર્ચ, ડેટા ગવર્નન્સ વિચારણાઓ

સ્થાનિક LLMs

ગુણ: પ્રાઇવસી, નિયંત્રણ, ખર્ચની આગાહી

વિપક્ષ: હાર્ડવેર માંગ, મોડેલ ગુણવત્તા બદલાય છે, વધુ ટ્યુનિંગની જરૂર છે

મોડેલ બેકએન્ડ અને મેમરી મર્યાદાઓને રૂપરેખાંકિત કરવા માટે સત્તાવાર સ્થાનિક LLMs સૂચનાઓ જુઓ.

ટીમ પ્લે: સહયોગી પ્રવાહમાં OpenHands નો ઉપયોગ કરવો

શાખા-પ્રથમ વર્કફ્લો: OpenHands ને ફીચર શાખા બનાવવા અને PR સમીક્ષા માટે ફેરફારો કરવા માટે કહો.

કમીટ સ્વચ્છતા: તેને સ્પષ્ટ સંદેશાઓ અને સંદર્ભ ઇશ્યૂ નંબરો સાથે અણુ કમિટ્સ બનાવવા માટે કહો.

PR નમૂનાઓ: PR નમૂનાઓ જનરેટ કરો અને લાગુ કરો જેથી સમીક્ષકોને ખબર પડે કે શું બદલાયું છે અને શા માટે.

કોડ માલિકો: AI-જનરેટેડ PR ને યોગ્ય સમીક્ષકોને રૂટ કરવા માટે CODEOWNERS સાથે જોડો.

સામાન્ય સમસ્યાઓનું નિવારણ

તે અટકી જાય છે અથવા લૂપ થાય છે: અવકાશને સંકુચિત કરો. તેને તેનું આગલું પગલું સમજાવવા માટે કહો. નિષ્ફળ પરીક્ષણ પ્રદાન કરો.

ગંદી તફાવતો: નાની, સ્ટેજ કરેલી યોજનાની વિનંતી કરો—પહેલા પરીક્ષણો, પછી ન્યૂનતમ કોડ ફેરફારો.

ખોટી ફાઇલ સંપાદનો: ચોક્કસ પાથ સ્પષ્ટ કરો અને તેને સીમાઓની યાદ અપાવો.

સ્થાનિક રીતે પાસ થાય છે પરંતુ CI માં નિષ્ફળ જાય છે: CI પર્યાવરણની વિગતો અને લોગ શેર કરો; તેને કન્ટેનર સાથે નકલ કરવા દો.

પર્ફોર્મન્સ ટીપ્સ અને પાવર મૂવ્સ

વોર્મ-સ્ટાર્ટ સંદર્ભ: તેને પહેલા કી ફાઇલો વાંચવા માટે કહો ({a2}README{/a2}, {a4}package.json{/a4}, મુખ્ય સેવા ફાઇલો).

તેને સ્ક્રિપ્ટ્સ આપો: {a2}make test{/a2} અથવા {a4}npm run verify{/a4} પ્રદાન કરો જેથી તે ઝડપથી માન્ય કરી શકે.

ડોમેન શીખવો: ટૂંકી આર્કિટેક્ચરલ વિહંગાવલોકન ઓફર કરો; તે ઓછી તાર્કિક ભૂલોમાં ચૂકવણી કરે છે.

શૈલી લાગુ કરો: {a2}.eslintrc{/a2}, {a4}.prettierrc{/a4}, {a6}black{/a6}/{a8}ruff{/a8} રૂપરેખાંકનો તરફ નિર્દેશ કરો જેથી તે યોગ્ય રીતે ફોર્મેટ થાય.

ચેકપોઇન્ટ્સનો ઉપયોગ કરો: દરેક માઇલસ્ટોન પછી, તેને ટ્રેક પર રાખવા માટે સારાંશ અને આગલા પગલાં માટે પૂછો.

વાસ્તવિક-દુનિયાનું દૃશ્ય: બગ રિપોર્ટથી એક કલાકમાં પેચ સુધી

સ્થિતિ: ઉત્પાદન બગ {a2}orders{/a2} API માં ખરાબ રીતે બનેલા JSON પેલોડ્સ પર અનહૅન્ડલ્ડ 500s છોડે છે.

તમારું પ્રોમ્પ્ટ: "{a2}orders{/a2} POST માં ખરાબ રીતે બનેલા JSON પર 500 નું પુનઃઉત્પાદન કરો. સ્કીમા માન્યતા ઉમેરો અને ભૂલ વિગતો સાથે {a4}400{/a4} પરત કરો. ખરાબ રીતે બનેલા પેલોડ્સને આવરી લેવા માટે પરીક્ષણો અપડેટ કરો."

OpenHands પ્રક્રિયા:

API સ્થાનિક રીતે ચલાવે છે, ભૂલનું પુનઃઉત્પાદન કરે છે

માન્યતા સ્તર અને ભૂલ હેન્ડલર ઉમેરે છે

પરીક્ષણો અપડેટ કરે છે અને ખાતરી કરે છે કે CI પાસ થાય છે

ચેન્જલોગ એન્ટ્રી સાથે કોમ્પેક્ટ PR બનાવે છે

બચાવેલ સમય: તમે અસર વિશ્લેષણ અને રોલઆઉટ પર ધ્યાન કેન્દ્રિત કર્યું, જ્યારે OpenHands એ સ્કેફોલ્ડિંગને સંભાળ્યું.

એકીકરણો જે OpenHands ને સુપરચાર્જ કરે છે

પરીક્ષણ દોડવીરો: pytest, Jest, Vitest, JUnit

બનાવવાના સાધનો: Vite, Webpack, Rollup, Babel

પેકેજ મેનેજર્સ: npm, pnpm, yarn, pip/poetry

લિંટર્સ/ફોર્મેટર્સ: ESLint, Prettier, black, ruff

કન્ટેનર: CI સાથે સ્થાનિક સમાનતા માટે ડોકર કમ્પોઝ

આ સાધનોને પ્રમાણિત કરીને, OpenHands તમારા સ્ટેક વિશે વધુ વિશ્વસનીય રીતે તર્ક કરી શકે છે અને દેવ લૂપને વધુ સ્વચાલિત કરી શકે છે.

માર્ગ દ્વારા: OpenHands ની સાથે Sider.AI નો ઉપયોગ કરવો

સંબંધિતતા સ્કોર: 8/10. જો તમે OpenHands નો ઉપયોગ તમારા AI એન્જિનિયર તરીકે કરી રહ્યા છો, તો તેને સ્પેક્સ, PR વર્ણનો અને દસ્તાવેજીકરણ માટે સંશોધન અને ડ્રાફ્ટિંગ કોપાયલોટ સાથે જોડી દેવાનું યોગ્ય છે. માર્ગ દ્વારા, Sider.AI તમને તકનીકી સ્પેક્સનો ઝડપથી ડ્રાફ્ટ કરવામાં, RFC નો સારાંશ આપવામાં અથવા OpenHands રન લોગને સ્વચ્છ ચેન્જલોગ અને પ્રકાશન નોંધોમાં રૂપાંતરિત કરવામાં મદદ કરી શકે છે. સંયોજન સંદર્ભ-સ્વિચિંગ ઘટાડે છે: OpenHands કોડ ક્રિયાઓને હેન્ડલ કરે છે જ્યારે Sider.AI પરિણામોને સ્વચ્છ, વપરાશકર્તા-સામનો કરતા ડોક્સમાં ફેરવે છે.

સુરક્ષા, પ્રાઇવસી અને પાલન તપાસસૂચિ

env vars માં સિક્રેટ્સ રાખો; પ્રોમ્પ્ટ્સમાં ક્યારેય કી એમ્બેડ કરશો નહીં

દરેક AI-જનરેટેડ ફેરફારની સમીક્ષા કરો જેમ તમે જુનિયર દેવના PR ની કરશો

ઓડિટબિલિટી માટે આદેશો અને ક્રિયાઓ લોગ કરો

ટૂલચેઇન સંસ્કરણોને પિન કરો; લોકફાઇલોમાં આકસ્મિક અપગ્રેડ્સ ટાળો

જો ક્લાઉડ LLMs નો ઉપયોગ કરો છો, તો તમારી ડેટા રીટેન્શન પોલિસી સાથે સંરેખિત કરો

OpenHands નો ઉપયોગ ક્યારે ન કરવો

મજબૂત પરીક્ષણ અથવા સ્પેક સ્કેફોલ્ડિંગ વિના નવલકથા અલ્ગોરિધમ ડિઝાઇન

મજબૂત સમીક્ષા પ્રક્રિયા વિના અત્યંત નિયંત્રિત કોડબેઝ

વન-ઓફ થ્રોઅવે સ્ક્રિપ્ટ્સ જ્યાં મેન્યુઅલ કોડિંગ ઝડપી હોય છે

OpenHands સાથે તમારી પ્રથમ 60 મિનિટ: એક મીની પ્લેબુક

મિનિટ 0–10: સત્તાવાર ક્વિકસ્ટાર્ટનો ઉપયોગ કરીને ઇન્સ્ટોલ કરો અને લોંચ કરો

મિનિટ 10–20: તમારી રેપોને કનેક્ટ કરો; તેને પ્રોજેક્ટ સ્ટ્રક્ચરને મેપ કરવા માટે કહો

મિનિટ 20–35: એક નાનો, પરીક્ષણ કરી શકાય તેવો ધ્યેય વ્યાખ્યાયિત કરો; તેની યોજનાને મંજૂરી આપો

મિનિટ 35–50: તેને અમલ કરવા અને પરીક્ષણો ચલાવવા દો; જરૂર મુજબ નજ કરો

મિનિટ 50–60: તફાવતોની સમીક્ષા કરો, સુધારો કરો અને ફીચર શાખામાં મર્જ કરો

કી લિંક્સ અને આગલા પગલાં

OpenHands માટે સત્તાવાર "સ્ટાર્ટ બિલ્ડિંગ" અને વપરાશ ડોક્સ: ટીપ્સ, ક્વિકસ્ટાર્ટ અને શ્રેષ્ઠ પ્રથાઓ.

સ્થાનિક LLM સેટઅપ માર્ગદર્શિકા: તમારા મશીન પર સંપૂર્ણપણે OpenHands રૂપરેખાંકિત કરો અને ચલાવો.

VM પર સમુદાય-સંચાલિત ઇન્સ્ટોલ વોકથ્રુ: વાસ્તવિક-દુનિયાના ઇન્સ્ટોલ પગલાં અને ઝડપી ડેમો પ્રોજેક્ટ.

ટેકવેઝ

સ્પષ્ટ સ્વીકૃતિ માપદંડ સાથે ટિકિટની જેમ ટાસ્ક ફ્રેમ કરો.

પુનરાવર્તનોને નાના રાખો; વહેલા અને વારંવાર પરીક્ષણ કરો.

ગાર્ડરેલ્સનો ઉપયોગ કરો અને ફેરફારોની સમીક્ષા કરો—તેને જુનિયર ટીમના સાથીની જેમ ગણો.

સુવિધા માટે ક્લાઉડ પસંદ કરો, પ્રાઇવસી માટે સ્થાનિક મોડેલ્સ.

સ્પેક્સ અને પ્રકાશન નોંધોને ઝડપી બનાવવા માટે દસ્તાવેજીકરણ સાધનો (દા.ત., Sider.AI) સાથે જોડો.

FAQ

{a0}Q1:હું AI OpenHands ને ઝડપથી કેવી રીતે ઇન્સ્ટોલ અને ઉપયોગ કરવાનું શરૂ કરી શકું? પૂર્વજરૂરીયાતો ઇન્સ્ટોલ કરવા માટે સત્તાવાર ક્વિકસ્ટાર્ટનો ઉપયોગ કરો, સપોર્ટેડ LLM (ક્લાઉડ અથવા સ્થાનિક) માં પ્લગ કરો અને તમારી રિપોઝીટરીને કનેક્ટ કરવા માટે UI લોંચ કરો. "સ્ટાર્ટ બિલ્ડિંગ" ડોક્સ સેટઅપ ટીપ્સ સાથે સ્ટેપ-બાય-સ્ટેપ સૂચનાઓ પ્રદાન કરે છે.{/a0}{a0}Q2:શું હું ક્લાઉડ મોડેલને બદલે સ્થાનિક LLM સાથે OpenHands ચલાવી શકું? હા. સ્થાનિક મોડેલ બેકએન્ડને રૂપરેખાંકિત કરવા અને સંદર્ભ સેટિંગ્સને સમાયોજિત કરવા માટે સ્થાનિક LLMs માર્ગદર્શિકાને અનુસરો. આ પ્રાઇવસી-સંવેદનશીલ પ્રોજેક્ટ્સ માટે અથવા API ખર્ચને ટાળવા માટે આદર્શ છે.{/a0}{a0}Q3:કોડિંગ કાર્યો માટે OpenHands ને પ્રોમ્પ્ટ કરવાની શ્રેષ્ઠ રીત કઈ છે? સંક્ષિપ્ત ટિકિટ જેવી પ્રોમ્પ્ટ્સ લખો: ધ્યેય વ્યાખ્યાયિત કરો, ચોક્કસ ફાઇલોનો સંદર્ભ લો, સીમાઓ સેટ કરો અને સ્વીકૃતિ માપદંડ શામેલ કરો. પ્રગતિને માન્ય કરવા માટે તેને પરીક્ષણો બનાવવા અથવા ચલાવવા માટે કહો.{/a0}{a0}Q4:શું AI OpenHands નો ઉપયોગ ઉત્પાદન કોડ પર કરવા માટે સલામત છે? તેને જુનિયર ડેવલપરની જેમ ગણો: ફેરફારોને માન્ય કરવા માટે શાખા સુરક્ષા, કોડ સમીક્ષા અને CI નો ઉપયોગ કરો. આદેશો માટે ગાર્ડરેલ્સ ઉમેરો અને પ્રોમ્પ્ટ્સમાંથી સિક્રેટ્સ રાખો.{/a0}{a0}Q5:OpenHands પરંપરાગત કોડ સહાયક સાથે કેવી રીતે તુલના કરે છે? માત્ર ચેટ-ઓન્લી સાધનોથી વિપરીત, OpenHands આદેશો ચલાવી શકે છે, ફાઇલો સંપાદિત કરી શકે છે અને તમારી રેપોમાં સ્વાયત્ત રીતે પુનરાવર્તન કરી શકે છે. તે ફીચર્સ, ડિબગીંગ અને પરીક્ષણો જેવા એન્ડ-ટુ-એન્ડ કાર્યો માટે બનાવવામાં આવ્યું છે.{/a0}