Ana içeriğe geç

Open-Interpreter: Açık Kaynaklı Yapay Zekâ Kodlama Aracısı Rehberi

Open Interpreter'ın ne olduğunu, açık kaynaklı kodlama aracısının nasıl çalıştığını, nasıl kurulup kullanılacağını ve model ile aracı kılıfı desteğinin diğer yapay zekâ kodlama araçlarıyla nasıl karşılaştırıldığını öğrenin.
· 15 dk. oku

Yapay Zeka ile Keşfedin

Daha önce başka bir model için tasarlanmış bir kodlama aracısında açık ağırlıklı bir modeli çalıştırdıysanız, bunun pek iyi bir fikir olmadığını biliyorsunuzdur.

Model genelde araç şemalarını yanlış okur ve siz durdurana kadar aynı hatalı komutu tekrarlar. Aracının asıl tasarlandığı modele geri döndüğünüzde aynı görev sorunsuz şekilde tamamlanır. Sorun çoğunlukla modelde değil, etrafındaki aracı kılıfındadır; çünkü komut istemleri ve araç formatları başka birine göre ayarlanmıştır.

Open Interpreter bunu, her modelin ayarlandığı kılıfı (Claude Code veya Kimi Code gibi) taklit ederek çözer. Terminalinizden çalışan açık kaynaklı bir yapay zekâ kodlama aracısıdır ve mevcut sürüm, hatırlıyor olabileceğiniz Python tabanlı bilgisayar asistanı değil, OpenAI'nin Codex'i üzerine kurulu bir Rust projesidir.

Bu yazıda, kurulum, model ve kılıf ayarı, uygulamalı bir kodlama iş akışı ve Open Interpreter'ın Claude Code, OpenCode ve Codex ile karşılaştırmasını adım adım göstereceğim.

Yapay zekâ aracılarında yeni misiniz? Yapay Zekâ Aracılarına Giriş kursumuza kaydolun ve temelleri bir öğleden sonra öğrenin.

Open Interpreter Nedir?

Open Interpreter bir yapay zekâ modeline projenize ve bir geliştiricinin kullanacağı araçlara erişim verir.

Sadece görevi yalın İngilizceyle tarif etmeniz yeter; aracı kodunuz üzerinde çalışır. Şunlarla çalışabilir:

  • Dosyalar: Kodunuzu okur ve düzenler
  • Komutlar: Kabuk komutları, betikler ve derleme adımlarını çalıştırır
  • Depolar: Git ile çalışır; proje geçmişini kontrol edebilir ve yaptığı değişikliklerin farkını gösterebilir
  • Geliştirme araçları: Kendi işini kontrol etmek için test çalıştırıcıları ve linter'lar kullanır
  • Çok adımlı görevler: İlk incelemeden test edilmiş düzeltmeye kadar bu eylemleri zincirler

Proje, Apache 2.0 lisansı altında açık kaynaklıdır. Ayrıca tek bir model sağlayıcıyla sınırlı değildir. Barındırılan modellere, açık ağırlıklı modellere veya yerel makinenizde çalışan modellere bağlayabilirsiniz.

Eylül 2026 itibarıyla ana depoda 68.000'den fazla GitHub yıldızı vardır.

Open Interpreter Nasıl Çalışır

Open Interpreter bir döngü içinde çalışır:

  1. Görev: Ne istediğinizi tarif edersiniz, örneğin "başarısız testi düzelt"
  2. İnceleme: Model proje yapısını ve ilgili dosyaları okur
  3. Planlama: Görevin hangi araçlara veya eylemlere ihtiyaç duyduğuna karar verir
  4. Düzenlemeler: Dosyaları okur veya değiştirir
  5. Komutlar: Bir test paketi gibi kabuk komutları çalıştırır
  6. Değerlendirme: Çıktıyı kontrol eder ve değişikliğin işe yarayıp yaramadığını görür
  7. Yineleme: Görev tamamlanana veya girdiğinize ihtiyaç duyulana kadar 2-6. adımları tekrarlar

Bu adımların bazıları, izin ayarlarına bağlı olarak önce onayınızı gerektirir. Güvenlik bölümünde bunları ele alacağım.

İşte daha görsel bir özet:

Open Interpreter nasıl çalışır

Open Interpreter nasıl çalışır

Burada unutulmaması gereken şey, modele doğrudan konuşmadığınızdır. Open Interpreter, görevinizi etkin kılıfın komut istemleri ve araç tanımlarıyla biçimlendirilmiş olarak modele gönderir. Model araç çağrıları ister ve Open Interpreter bunları kod tabanınız üzerinde çalıştırır. Ardından sonuçlar bir sonraki adım için tekrar modele döner.

Model ile kılıf ayrı katmanlar olduğu için, kurulumu yeniden yapmadan ikisini de değiştirebilirsiniz.

Open Interpreter Nasıl Kurulur

Open Interpreter bağımsız bir ikili dosya olarak kurulur, bu yüzden Python veya pip'e ihtiyacınız yoktur.

Eski bir blog yazısı size pip install open-interpreter çalıştırmanızı söylüyorsa, miras kalan Python sürümünü anlatıyordur. Bu komut, bu yazıda ele aldığım Rust tabanlı kodlama aracısını vermez.

Makinenizde Git de bulunması iyi olur. Open Interpreter onsuz da çalışır, ancak Git, depo farkındalığı olan bir oturum ve diff'ler sağlar.

macOS ve Linux

Terminalinizden kurulum betiğini çalıştırın:

curl -fsSL https://www.openinterpreter.com/install | sh

Betik, platformunuza uygun sürümü indirir ve interpreter komutunu ~/.local/bin içine yerleştirir.

Windows

PowerShell'i açın ve şunu çalıştırın:

irm https://www.openinterpreter.com/install.ps1 | iex

Linux tarzı bir kurulum tercih ediyorsanız WSL de desteklenir. Bu durumda, WSL terminalinizin içinde macOS ve Linux komutunu çalıştırın.

Kurulumu doğrulayın

Terminalinizi yeni PATH'i alması için yeniden başlatın ve sürümü kontrol edin:

interpreter --version

Bir sürüm numarası görüyorsanız kurulum başarılı olmuştur.

Open Interpreter sürüm kontrolü

Open Interpreter sürüm kontrolü

Etkileşimli bir oturum başlatın

Herhangi bir dizinden bir oturum başlatın:

interpreter

Aynı komutun kısa takma adı olan i'yi de yazabilirsiniz.

Open Interpreter, görevleri yalın İngilizceyle tarif ettiğiniz bir terminal arayüzü açar. İlk kez başlattığınızda sizden bir model sağlayıcı bağlamanızı ister. Bir sonraki bölümde Ollama üzerinden yerel bir model kullanacağım; şimdilik bu adımı atlayabilirsiniz.

Open Interpreter etkileşimli oturum

Open Interpreter etkileşimli oturum

Oturumdan çıkmak için /exit yazın.

Open Interpreter Nasıl Kullanılır

Bir kodlama aracısını anlamanın en hızlı yolu ona bir görev vermek ve ne yaptığını izlemektir.

Bu bölümün tamamında küçük bir alışkanlık takipçisi projesi kullanacağım. Bir fonksiyonu, bir test dosyası ve bir hatası var.

Demo projeyi oluşturun

Proje, bir alışkanlık için ardışık günlerin en uzun serisini hesaplar. Örneğin, üst üste kaç gün egzersiz yaptığınızı sayar.

Bir proje klasörü ve sanal ortamla başlayın:

mkdir habit-tracker && cd habit-tracker
python3 -m venv .venv
source .venv/bin/activate
pip install pytest

habits.py'yi aşağıdaki kodla oluşturun:

def longest_streak(dates):
    """Return the longest run of consecutive days.

    Each date is a 'YYYY-MM-DD' string, for example "2026-03-14".
    Duplicate dates count once.
    """
    days = sorted(set(dates))
    if not days:
        return 0

    longest = current = 1
    for previous, today in zip(days, days[1:]):
        if int(today[8:10]) - int(previous[8:10]) == 1:
            current += 1
            longest = max(longest, current)
        else:
            current = 1
    return longest

Ardından test_habits.py'yi oluşturun:

from habits import longest_streak


def test_streak_within_one_month():
    dates = ["2026-03-01", "2026-03-02", "2026-03-03", "2026-03-10"]
    assert longest_streak(dates) == 3


def test_duplicate_dates_count_once():
    dates = ["2026-03-01", "2026-03-01", "2026-03-02"]
    assert longest_streak(dates) == 2


def test_streak_across_month_boundary():
    dates = ["2026-01-30", "2026-01-31", "2026-02-01"]
    assert longest_streak(dates) == 3

Fonksiyonda bir hata var. Bunu ben söylemeyeceğim; bulmak aracının işi.

Sanal ortam ve önbellek dosyaları depoya girmesin diye bir .gitignore dosyası ekleyin:

.venv/
__pycache__/
.pytest_cache/

Şimdi projeyi commit'leyin:

git init
git add .
git commit -m "Initial commit"

Bu commit size temiz bir başlangıç noktası verir. Daha sonra, aracının tam olarak neyi değiştirdiğini görmek için kullanacaksınız.

Hatanın doğrulanması için testleri çalıştırın:

python -m pytest

Alışkanlık takipçisi test sonucu

Alışkanlık takipçisi test sonucu

İki test geçiyor, biri başarısız. Open Interpreter'ın çözmesi gereken sorun bu.

Open Interpreter'ı yerel bir modelle başlatın

Kurulu ve çalışan Ollama'ya ihtiyacınız olacak. Ayrıca araç çağrısını destekleyen bir modele de ihtiyaç var; indirin:

ollama pull qwen3-coder:30b

Ardından, proje klasöründen Open Interpreter'ı başlatın. Aracının sanal ortamınızdaki pytest kurulumunu kullanabilmesi için aynı terminali kullanın:

interpreter --oss --local-provider ollama -m qwen3-coder:30b

Her bayrak ne yapar:

  • --oss: Yerel bir açık kaynak sağlayıcı kullanır

  • --local-provider ollama: LM Studio yerine Ollama'yı seçer

  • -m qwen3-coder:30b: Bu çalıştırma için modeli ayarlar

/status komutunu çalıştırarak etkin sağlayıcıyı, modeli, sandbox modunu ve onay politikasını doğrulayın.

Yerel bir Ollama modeliyle Open Interpreter oturumu

Yerel bir Ollama modeliyle Open Interpreter oturumu

Ondan hatayı araştırmasını isteyin

Aracının henüz bir şeyi düzenlemesini istemiyorsunuz. Önce bir teşhis isteyin:

The tests in this project are failing. Find the cause and explain how you'd fix it. Don't edit any files yet.

Aracı, yanıt vermeden önce genellikle dosyaları okur ve testleri çalıştırır. Komutlar sandbox içinde çalışır ve aracı sandbox'ın izin verdiğinden daha fazla erişime ihtiyaç duyarsa, önce onayınızı ister.

Open Interpreter çıktısı

Open Interpreter çıktısı

Önerilen düzeltmeyi gözden geçirin

Herhangi bir şeyi onaylamadan önce açıklamayı okuyun.

Doğru bir teşhis, fonksiyonun yalnızca ayın gününü karşılaştırdığını ve dolayısıyla seri yeni bir aya geçtiğinde koptuğunu söyleyecektir. İyi bir düzeltme, Python'un datetime modülünden date.fromisoformat() gibi tam tarihleri karşılaştırmaktır.

Teşhis yanlışsa, aracı kodu düzenlemeden önce aynı oturumda düzeltin.

Open Interpreter düzeltme önerisi

Dosyayı düzenlemesine ve testleri çalıştırmasına izin verin

Planı onayladıktan sonra, düzeltmeyi uygulayın:

Apply the fix to habits.py, then run the tests.

Aracı dosyayı düzenler ve pytest'i yeniden çalıştırır. Üç testin de geçmesini görmek istersiniz.

Düzeltmeden sonra tüm testler geçiyor

Düzeltmeden sonra tüm testler geçiyor

Diff'i inceleyin

Testlerin geçmesi, kodunuzdaki hatanın çözüldüğü anlamına gelmeyebilir. Belki de test, hatayı dolanacak biçimde güncellenmiştir. Kodu yine de gözden geçirmeniz gerekir.

Çalışan ağaçtaki değişiklikleri görmek için oturum içinde /diff çalıştırın. Çıktıktan sonra git diff de çalıştırabilirsiniz.

Open Interpreter'ın yaptığı değişikliklerin diff'i

Open Interpreter'ın yaptığı değişikliklerin diff'i

Tam diff modelinize bağlıdır; sizinki satır satır yukarıdakiyle uyuşmayabilir. Değişikliği beğendiyseniz commit'leyin; beğenmediyseniz orijinal dosyayı geri yükleyin:

git restore habits.py

Fikir bu. Siz sorunu tarif edersiniz, aracı araştırır ve düzeltir, siz de değişiklikler kodunuza girmeden önce her birini gözden geçirirsiniz.

Open Interpreter'daki Modeller

Open Interpreter, kendi modelinizi getirmenizi gerektirir.

Her istek şu üç katmandan geçer:

KatmanÖrnekNeyi kontrol eder
Sağlayıcıollamaİsteklerin nereye gittiği ve nasıl kimlik doğruladığınız
Modeldevstral-small-2İşi yapan model
KılıfnativeModelin etrafındaki komut istemleri, araçlar ve ileti biçimi

İstek katmanları

Şunlara bağlanabilirsiniz:

  • Barındırılan modeller: OpenAI ve Anthropic gibi sağlayıcılardan ticari modeller; oturum açma veya API anahtarıyla
  • API üzerinden açık ağırlıklı modeller: Kimi K3 ve DeepSeek gibi modeller; kendi sağlayıcılarından veya OpenRouter gibi geçitler üzerinden
  • Yerel modeller: Ollama veya LM Studio üzerinden kendi donanımınızda çalışan modeller; API anahtarı gerektirmeyen yerleşik sağlayıcılardır

Sağlayıcı listesi, herkese açık bir model kataloğundan üretilir ve yalnızca araç çağrısını destekleyen modeller tutulur. Beklediğiniz bir model eksikse, genellikle sebep budur.

ollama-cloud'a dikkat etmeyi unutmayın. Ayrı bir barındırılan sağlayıcıdır; istekleriniz makinenizden çıkar. Yalnızca yerleşik ollama sağlayıcısı modelleri yerelde çalıştırır.

Modeller arasında geçiş

Modeli üç düzeyde değiştirebilirsiniz:

  • Bir oturum içinde: Sağlayıcıyı, modeli ve akıl yürütme çabasını seçmek için /model çalıştırın

  • Tek bir çalıştırma için: Önceki bölümde olduğu gibi -m bayrağını geçin

  • Varsayılan olarak: Yapılandırma dosyanızda ayarlayın

Hangi sağlayıcı ve modelin etkin olduğunu görmek için istediğiniz zaman /status çalıştırabilirsiniz.

Sağlayıcı yapılandırması

Open Interpreter ayarlarını ~/.openinterpreter/config.toml dosyasından okur. Önceki bölümdeki Ollama kurulumunu varsayılanınız yapmak için şu iki satırı ekleyin:

model_provider = "ollama"
model = "qwen3-coder:30b"

Bundan sonra interpreter bu modelle başlar ve herhangi bir bayrağa ihtiyaç duymazsınız.

Barındırılan sağlayıcılar API anahtarlarını ortam değişkenlerinden okur. Örneğin, DeepSeek DEEPSEEK_API_KEY bekler:

export DEEPSEEK_API_KEY="your-api-key"

OpenAI uyumlu herhangi bir uç noktayı özel sağlayıcı olarak da ekleyebilirsiniz:

model_provider = "my-provider"
model = "my-model"

[model_providers.my-provider]
name = "My Provider"
base_url = "https://api.example.com/v1"
env_key = "MY_PROVIDER_API_KEY"
wire_api = "chat"

wire_api ayarı, uç noktanın hangi istek biçimini beklediğini Open Interpreter'a söyler. OpenAI uyumlu Chat Completions için chat, OpenAI Responses API için responses ve Anthropic tarzı uç noktalar için messages kullanın.

Güvenilen bir projenin, kullanıcı yapılandırmanızı geçersiz kılan kendi .openinterpreter/config.toml'u da olabilir. Komut satırı bayrakları her ikisini de geçersiz kılar. Hangi değerin kazanacağından emin değilseniz, etkin ayarları ve kaynaklarını görmek için /debug-config çalıştırın.

Neden hem model hem kılıf önemlidir

Model, aracının kodunuzu ne kadar iyi anladığını belirler. Kılıf, modelin görevi ve araçları nasıl gördüğünü belirler.

İkisine de ihtiyacınız var. Uymayan bir kılıf içindeki iyi bir model hatalı araç çağrıları gönderir ve sonuçları yanlış okur. Ve iyi bir kılıf, kodu anlamayan bir modeli telafi edemez.

Bu yüzden Open Interpreter, siz bir model seçtiğinizde bir kılıf da seçer. Örneğin:

  • Claude modelleri claude-code kılıfını alır

  • Kimi modelleri kimi-code alır

  • Qwen modelleri qwen-code alır

  • DeepSeek modelleri claude-code-bare alır

Diğer model aileleri için, /harness ile kılıfı kendiniz seçebilirsiniz.

Burada hatırlanması gereken, zayıf bir sonucun her zaman zayıf bir model anlamına gelmediğidir. Modeli değiştirmeden önce, aynı modeli farklı bir kılıfla deneyin; bunu bir sonraki bölümde ayrıntılı olarak ele alacağım.

Open Interpreter Aracı Kılıfları

Kılıf öykünmesi, Open Interpreter'ın mevcut sürümünün var olmasının başlıca nedenidir.

Bir aracı kılıfı, modeli bir aracıya dönüştüren modelin çevresindeki her şeydir. Şunları içerir:

  • Talimatlar: Modele nasıl davranacağını ve ne zaman araçları kullanacağını söyleyen sistem komutu, vb.
  • Araçlar: Modelin gerçekleştirebileceği eylemler (dosya okuma veya komut çalıştırma gibi) ve her çağrının uyması gereken tam şema
  • Etkileşim kalıpları: Araç çağrıları ve sonuçlarının konuşmaya nasıl eklendiği ve döngünün girdi istemek için ne zaman durduğu
  • Yürütme ortamı: Komutların nerede çalıştığı, nelere erişebildiği ve nelerin onayınızı gerektirdiği

Basitçe söylemek gerekirse, kılıf modelin görevi nasıl gördüğünü ve kararlarının nasıl eyleme dönüştüğünü belirler.

Open Interpreter'ın yerleşik kılıf kipleri vardır. En çok kullanacaklarınız şunlardır:

  • native: Codex'ten miras Open Interpreter'ın kendi kılıfı

  • claude-code: Anthropic'in Claude Code'unun komut istemlerini ve araç yüzeyini öykünür

  • kimi-code: Moonshot'ın Kimi modelleri için önerdiği Kimi Code kılıfının bir Rust yeniden uygulaması

  • qwen-code: Qwen modelleri için Alibaba'nın Qwen Code CLI'ını öykünür

  • swe-agent: GitHub sorunlarını çözmek için oluşturulmuş bir araştırma aracısı olan SWE-agent'ı öykünür

Tam listede claude-code-bare, kimi-cli, deepseek-tui, zcode ve minimal gibi varyantlar da vardır. Sürümünüzün neleri desteklediğini görmek için bir oturumda /harness çalıştırın.

Kılıflar arasında oturum sırasında /harness ile geçiş yapabilir veya ~/.openinterpreter/config.toml içinde varsayılan ayarlayabilirsiniz:

harness = "kimi-code"
harness_guidance = true

harness_guidance ayarı, kılıfın izin verdiği yerlerde bir güvenilirlik yönlendirmesi ekler. Daha sıkı bir öykünme istiyorsanız false olarak ayarlayın. harness'ı boş bırakırsanız, Open Interpreter önceki bölümde gördüğünüz gibi model ailesine göre bir kılıf seçer.

Kılıf neden önemlidir

Çoğu model satıcısı, kodlama modellerini belirli bir aracı kurulumunda ayarlar ve bununla birlikte kullanılacak bir kılıf önerisi yayınlar.

Model o kılıfa alışır. Komut istemi stilini, araç adlarını, dosya düzenleme formatını ve araç sonuçlarının dönüş şeklini öğrenir.

Diyelim ki arama-değiştirme düzenlemeleri için ayarlanmış bir modeli, tam yama dosyaları bekleyen bir kılıf içinde çalıştırıyorsunuz. Model yapılacak değişikliği biliyor ama değişikliği yanlış formatta anlatıp duruyor. Aracı döngüsü, ilerleme olmadan belirteç tüketiyor.

Araç sonuçları da aynı şekilde işler. Kılıf, sonuçları modelin görmediği bir formatta döndürürse, model onları yanlış okur. Kılıf, turlar arasında modelin muhakemesini silerse, düşünen bir model kendi planının izini kaybeder.

Bu, aynı modelin, ağırlıklarında hiçbir değişiklik olmadan, bir aracıda iyi bir diğerinde kötü görünebileceği anlamına gelir. Bu ayrıca, kodlama kıyaslamalarının genellikle her çalışma için kullanılan kılıfı adlandırmasının nedenidir.

Sınır modelleri alışılmadık bir kılıftan toparlanma eğilimindeyken, daha küçük ve ucuz modeller genellikle toparlanamaz. Open Interpreter her modeli tek bir formata zorlamaz; formatı modele uydurur.

Bunu demo projeyle kendiniz test edebilirsiniz. git restore habits.py ile orijinal dosyayı geri yükleyin, /harness ile kılıfı değiştirin ve aracıya aynı istemi tekrar verin. Ardından kaç adım sürdüğünü ve düzenlemeleri nasıl biçimlendirdiğini karşılaştırın.

Önemli Open Interpreter Özellikleri

Bu özelliklerin çoğunu yazıda zaten gördünüz. İşte her birinin günlük geliştirmede size sağladıkları.

Depo farkındalığı olan kodlama

Open Interpreter Git deponuzun içinde çalışır. Proje yapısını okur ve yaptığı değişiklikleri izler.

Burada iki eğik çizgi komutu yardımcı olur. /diff çalışma ağacındaki değişiklikleri gösterir ve /review commit'lemeden önce aracıdan mevcut değişiklikleri hata ve gerileme açısından kontrol etmesini ister. Aynı incelemeyi bir oturum açmadan da çalıştırabilirsiniz:

interpreter exec review --uncommitted

Oturumlar da kaydedilir. Bir görevin ortasında durursanız, interpreter resume --last kaldığınız yerden devam eder.

Terminal ve komut çalıştırma

Aracı, sizin çalıştıracağınız aynı komutları çalıştırır; örneğin test paketleri, linter'lar, derleme betikleri ve paket yöneticileri. Hepsi macOS, Linux ve Windows'ta yerel sandbox'larda çalışır.

Uzun süre çalışan komutlar arka planda çalışabilir. Bunları listelemek için /ps, sonlandırmak için /stop kullanın.

Betikler ve CI hatları için, interpreter exec etkileşimli arayüz olmadan bir görevi çalıştırır:

interpreter exec "fix the failing test"

Model esnekliği

/model ile istediğiniz an sağlayıcı ve model değiştirebilirsiniz. Yapılandırmanız, AGENTS.md ve becerileriniz değişimden sonra da geçerlidir.

Profiller burada faydalıdır. Diyelim ki rutin işler için ucuz bir model, kod incelemeleri için daha güçlü bir model istiyorsunuz. Her ikisini de yapılandırmanıza tanımlayabilirsiniz:

[profiles.review]
model_provider = "deepseek"
model = "deepseek-v4-pro"
sandbox_mode = "read-only"

Gerektiğinde interpreter --profile review ile başlayın.

Kılıf değiştirme

/harness, modeli değiştirmeden modelin görevi nasıl gördüğünü değiştirir. Bir model araç çağrılarıyla zorlandığında daha büyük bir modele geçmeden önce denenecek ilk şeydir.

MCP ve araçlar

Model Context Protocol (MCP), aracıya, belgeler sunucuları veya veritabanları gibi, birlikte çalışması için tasarlanmamış araçlara bağlanma imkânı verir. Sunucuları yapılandırmanıza eklersiniz:

[mcp_servers.docs]
command = "npx"
args = ["-y", "your-docs-mcp-server"]
default_tools_approval_mode = "prompt"

/mcp çalıştırarak yapılandırılmış sunucuları ve araçlarını görebilirsiniz. default_tools_approval_mode ayarı, aracının o sunucudan bir aracı kullanmadan önce sormasını sağlar.

Tersi de çalışır. interpreter mcp-server, Open Interpreter'ı bir MCP sunucusu olarak sunar ve interpreter acp, düzenleyicileri kodlama aracılarından bağlamak için açık bir standart olan Agent Client Protocol'ü destekleyen düzenleyiciler içinde çalıştırır.

Beceriler ve AGENTS.md

AGENTS.md, deponuzda, aracının her görevde okuduğu proje kurallarını içeren bir Markdown dosyasıdır. Alışkanlık takipçisi için şu şekilde olabilir:

# AGENTS.md
- Run the tests with python -m pytest before you finish a task.
- Use the Python standard library only. Don't add new dependencies.

/init de çalıştırabilirsiniz; aracı sizin için ilk sürümü yazar.

Beceriler, .agents/skills (proje içinde) veya ~/.agents/skills (kullanıcı için) klasörlerinde paketlenmiş, yeniden kullanılabilir iş akışlarıdır. Bir görev bir beceriyle eşleştiğinde aracı beceriyi otomatik olarak alır. Hangi becerilerin mevcut olduğunu görmek için /skills çalıştırın.

Her ikisi de paylaşılan biçimlerdir; aynı dosyalar, onları destekleyen diğer kodlama aracılarında da çalışır. Open Interpreter kancaları da destekler; bunlar, bir oturumun belirli noktalarında kendi komutlarınızı çalıştırır. /hooks ile gözden geçirir ve güvenirsiniz.

Sandbox ve onaylar

İki ayar, aracının ne yapabileceğini kontrol eder:

  • Sandbox modu: read-only, workspace-write veya danger-full-access

  • Onay politikası: untrusted, on-request veya never

Sandbox neyin mümkün olduğunu, onay politikası ise aracının ne zaman önce sorduğunu belirler. workspace-write ve on-request ile aracı projenizi düzenleyebilir ve testleri çalıştırabilir; ancak bunun ötesinde erişime ihtiyaç duyduğunda önce sorar.

Her ikisini de /permissions veya -s ve -a bayraklarıyla değiştirebilirsiniz. Her ikisini de atlayan ve belgelerde tehlikeli olarak etiketlenen bir --yolo bayrağı da vardır. Bu ayarları güvenlik bölümünde daha detaylı ele alacağım.

Yerel ve Açık Modeller için Open Interpreter

Open Interpreter, kendini düşük maliyetli modeller için oluşturulmuş bir kodlama aracısı olarak tanımlar.

En büyük tescilli kodlama aracılarının etrafı, satıcının kendi modelleriyle örülüdür. Open Interpreter size, tescilli modeller, barındırılan açık ağırlıklı modeller ve yerel modellerle çalışan tek bir aracı sunar.

Açık ağırlıklı modeller

Kimi, DeepSeek, GLM ve Qwen gibi açık ağırlıklı modellerin ağırlıkları herkese açıktır. Bunları üçüncü taraf bir sağlayıcı üzerinden veya kendi donanımınızda kullanabilirsiniz.

Bu size iki avantaj sağlar. Barındırılan açık ağırlıklı modeller genelde uç tescilli modellere kıyasla belirteç başına daha az maliyetlidir. Ayrıca tek bir sunucu ile sınırlı değilsiniz; çünkü aynı model, ağırlıklarının çalıştığı her yerde çalışır.

Open Interpreter'ın Kimi K3, DeepSeek ve GLM için özel sağlayıcı kılavuzları vardır. Bu model aileleri için eşleşen kılıfı da seçer.

Yerel çıkarım

Ollama ve LM Studio yerleşik sağlayıcılardır; böylece bir API anahtarı veya belirteç başına maliyet olmadan modelinizi kendi makinenizde çalıştırabilirsiniz.

Maliyet donanımdır. devstral-small-2'yi 64 GB birleşik belleğe sahip MacBook Pro M1 Max üzerinde test ettiğimde, model tek başına bunun 26 GB'ını kullandı. Varsayılan Ollama bağlam penceresi aracı döngüsü için çok küçüktü ve 128k belirteçte, bellek kullanımı oturum kilitlenene kadar artıp azaldı.

Kodlama aracılarının büyük bir bağlam penceresine ihtiyacı vardır; çünkü sistem komutu, araç tanımları, dosya içerikleri ve komut çıktılarının hepsinin sığması gerekir. Ollama, Codex tarzı aracılar için en az 64k belirteç önerir. Daha büyük bir bağlam penceresi, modelin üzerine ek bellek kullanır.

Maliyet ve gizlilik

Open Interpreter makinenizde çalışır, ancak modelin çalışması şart değildir.

Kodunuzun nereye gideceği sağlayıcıya bağlıdır:

  • Yerel sağlayıcı: Komut istemleri, dosya içerikleri ve komut çıktıları makinenizde kalır
  • Barındırılan sağlayıcı: Model açık ağırlıklı olsa bile tümü sağlayıcının sunucularına gider

Yapılandırmanız, oturumlarınız ve günlükleriniz, ne olursa olsun ~/.openinterpreter altında yerel olarak saklanır.

Daha fazla kontrol istiyorsanız, kendi çıkarım sunucunuza işaret eden özel bir sağlayıcı ekleyebilirsiniz. Örneğin şirketinizin GPU'larında bir vLLM dağıtımı gibi, OpenAI uyumlu API'ye sahip herhangi bir sunucu çalışır. Böylece altyapının size ait olduğu barındırılan bir kurulum elde edersiniz.

Araç kullanımı performansı

Açık modeller araç çağrısında eşit derecede iyi değildir. Zayıf araç kullanımı hatalı çağrılar, döngüler, erken durmalar veya yok sayılan komut çıktıları olarak karşınıza çıkar.

Doğru kılıf yardımcı olur; ancak çok adımlı bir görevi planlayamayan bir modeli düzeltemez. En çok sorun yaşayanlar daha küçük yerel modellerdir.

Yeni bir modeli gerçek bir projeye yönlendirmeden önce, bu yazıda gösterdiğim alışkanlık takipçisi gibi küçük bir depoda test edin. Bir zayıflık gösterirse, daha büyük bir modele geçmeden önce farklı bir kılıf deneyin.

İşte seçeneklerinizin hızlı bir özeti:

 Çıkarım nerede çalışırMaliyetKod makinenizden çıkar mı?
Tescilli barındırılan modelSatıcının sunucusuBelirteç başına veya abonelikEvet
Açık ağırlıklı barındırılan modelSağlayıcının sunucusuBelirteç başına, genelde daha düşükEvet
Açık ağırlıklı yerel modelKendi donanımınızDonanım ve elektrikHayır

Yerel ve açık modeller için Open Interpreter seçenekleri

Open Interpreter ve Diğer Yapay Zekâ Kodlama Aracıları

Open Interpreter, diğer terminal tabanlı kodlama aracılarının çoğuyla pek çok ortak noktaya sahiptir. Farklılıklar, araca kimin sahip olduğu ve hangi modellere göre inşa edildiğindedir.

Open Interpreter vs. Claude Code

Claude Code, Anthropic'in terminal kodlama aracısıdır. İlk fark sahipliktir - Claude Code tescillidir, Open Interpreter ise Apache 2.0 lisansı altında açık kaynaktır. Open Interpreter'ın her parçasını okuyabilir ve değiştirebilirsiniz.

İkinci fark model seçimidir. Claude Code, Claude modelleri için oluşturulmuştur. Diğer sağlayıcılardan Anthropic uyumlu uç noktalara yönlendirebilirsiniz; ancak kılıfı Claude'a göre ayarlı kalır. Open Interpreter, model seçimini temel bir özellik olarak ele alır.

Kılıf karşılaştırması işin ilginç kısmıdır. Claude Code, Open Interpreter'ın öykündüğü kılıflardan biridir. claude-code kipinde, herhangi bir model Open Interpreter çalışma zamanında Claude Code tarzı komut istemleri ve araçlar alır. Arayüz ve eğik çizgi komutları hâlâ Open Interpreter'ındır; yani farklı bir modelle aynı ürün değildir.

Her iki araç da terminal önceliklidir. Her birinin etkileşimli bir oturumu ve betikler ile CI için etkileşimsiz bir modu vardır. Proje talimatları için Claude Code CLAUDE.md'yi, Open Interpreter ise paylaşılan AGENTS.md biçimini okur.

Claude Code daha büyük bir ekosisteme sahiptir. IDE eklentileri, masaüstü ve web uygulamaları, eklenti pazarı, alt aracılar ve bir SDK ile gelir. Open Interpreter daha gençtir ve kendi ekosistemi yerine MCP, beceriler, AGENTS.md ve Agent Client Protocol gibi paylaşılan standartlara dayanır.

Claude modelleriyle çalışıyor ve en cilalı deneyimi istiyorsanız, Claude Code daha güvenli bir seçimdir. Diğer modelleri çalıştırmak veya tescilli bir araçtan kaçınmak istiyorsanız, Open Interpreter'ı tercih edin.

Open Interpreter vs. OpenCode

OpenCode en yakın eşleşmedir. Her ikisi de açık kaynaklı, terminal öncelikli ve uzun bir model sağlayıcı listesiyle çalışacak şekilde oluşturulmuştur.

Kâğıt üzerinde model desteği benzerdir. OpenCode 75'ten fazla sağlayıcıyı destekler ve Open Interpreter sağlayıcı listesini herkese açık bir model kataloğundan üretir. Her ikisi de Ollama üzerinden yerel modelleri çalıştırır.

Terminal deneyimi daha fazla farklıdır. OpenCode'un kendi TUI'ı, tür hataları gibi kod tanılamalarını modele geri besleyen Language Server Protocol (LSP) entegrasyonuna sahiptir. Open Interpreter'ın TUI'ı Codex'ten gelir.

Yapılandırma açısından, OpenCode bir opencode.json dosyası kullanır; Open Interpreter ise profillerle config.toml kullanır.

Aracı mimarisi ana farktır. OpenCode, TUI'ın yerel bir sunucunun bir istemcisi olduğu, diğer istemcilerin de bağlanabildiği istemci-sunucu olarak çalışır. Yerleşik build ve plan aracılarının yanı sıra özel aracılar ve alt aracılar destekler. Sistem komutunu her model ailesi için ayarlar; ancak araçlar ve döngü OpenCode'un kendisinin kalır. Open Interpreter daha ileri gider ve araç şemaları ile ileti biçimi dâhil olmak üzere tüm kılıfı değiştirir. Yeni derlemelerde bir opencode kılıf kipi bile bulunur.

Geliştirme tarafında, OpenCode kendi kod tabanıdır; ekibi ve topluluğu tarafından inşa edilir. Open Interpreter bir Codex çatalı üzerine inşa edilir; bu yüzden çalışma zamanının büyük bir kısmı yukarı akıştan gelir. Bu bir ödünleşimdir. Open Interpreter, Codex'in sandbox'ını ve çalışma zamanını hazır alır; OpenCode ise yığının tamamını kontrol eder.

Open Interpreter vs. Codex

Bunlar alışıldık anlamda rakip değildir. Open Interpreter, Codex'in bir çatalıdır.

Rust çalışma zamanı, TUI, sandbox, onaylar, AGENTS.md, beceriler, MCP, exec modu ve çoğu eğik çizgi komutunu paylaşırlar. Open Interpreter'ı çalıştırdığımda, oturum devam ipucunda hâlâ codex resume yazıyordu.

Codex, OpenAI'nin aracısıdır ve OpenAI modellerinin etrafında inşa edilmiştir. --oss ve özel sağlayıcılarla yerel modelleri destekler; ancak varsayılan deneyim OpenAI'yi hedefler.

Open Interpreter birkaç yönde Codex'i genişletir:

  • Kılıf öykünmesi: Her model ailesine uyması için komut istemlerini, araç şemalarını ve ileti biçimini değiştirir

  • Sağlayıcı desteği: Üretilmiş bir sağlayıcı kataloğuna ve Kimi K3, DeepSeek ve GLM için özel kılavuzlara sahiptir

  • Chat Completions: --chat-completions bayrağı, OpenAI uyumlu herhangi bir sağlayıcıyı çalıştırır

  • Codex SDK geçersiz kılması: Codex SDK üzerine inşa edilen uygulamalar, bunun yerine Open Interpreter üzerinden çalışabilir

Open Interpreter ayrıca yapılandırmasını ve oturumlarını ~/.openinterpreter altında saklar; böylece bir Codex kurulumu ile çakışmaz.

Çoğunlukla OpenAI modellerini kullanıyorsanız, Codex daha iyi bir seçimdir. Diğer modelleri kullanıyorsanız, Open Interpreter size aynı iş akışını, onlar için daha iyi destekle sunar.

Hızlı bir özet:

 LisansModellerKılıf yaklaşımıYapılandırma
Open InterpreterAçık kaynak (Apache 2.0)Herhangi bir sağlayıcı, barındırılan veya yerelModel başına kılıfı öykünürconfig.toml
Claude CodeTescilliClaude modelleri için oluşturulmuşClaude Code'un kendi kılıfısettings.json ve CLAUDE.md
OpenCodeAçık kaynak (MIT)75+ sağlayıcı, barındırılan veya yerelModel özelinde komut istemleri olan tek kılıfopencode.json
CodexAçık kaynak (Apache 2.0)--oss ile OpenAI modelleri için oluşturulmuşCodex'in kendi kılıfıconfig.toml

Open Interpreter'ın diğer yapay zekâ kodlama aracılarla karşılaştırması

Open Interpreter Güvenlik ve İzinler

Bir sohbet botunun yapabileceği en kötü şey, göz ardı edebileceğiniz kötü bir yanıt vermektir. Bir kodlama aracısı ise makinenizde komutlar çalıştırır, dosyaları okur ve yazar ve ağa erişebilir. Modelden gelen kötü bir karar veya bir komut istemi enjeksiyonu gerçek zarar verebilir. Komut istemi enjeksiyonu, aracıya okuduğu içeriklere (örneğin bir README dosyası veya web sayfası) gizlenmiş talimatlar anlamına gelir.

Open Interpreter, güvenlik modelini Codex çalışma zamanından devralır. İki katmanı vardır - mümkün olanı sınırlayan bir sandbox ve aracının ne zaman önce soracağını belirleyen bir onay politikası.

Komut çalıştırma ve dosya sistemi erişimi

Aracının çalıştırdığı her komut, macOS, Linux ve Windows'ta işletim sistemi düzeyinde bir sandbox'tan geçer. Üç sandbox modu vardır:

  • read-only: Aracı dosyaları okuyabilir, ancak hiçbir şeyi değiştiremez

  • workspace-write: Aracı proje klasörünüz içinde dosyaları düzenleyebilir ve komutlar çalıştırabilir

  • danger-full-access: Hiçbir sandbox yok

workspace-write ile dosya yazmaları etkin çalışma alanıyla sınırlıdır. Aracı kodunuzu düzeltebilir; ancak makinenizin başka yerlerindeki dosyaları düzenleyemez.

Ağ erişimi

workspace-write modunda, komutların varsayılan olarak ağ erişimi yoktur. Bu, indirmeleri engeller ve aracının kodunuzu bir yere göndermesini durdurur.

Bazı görevler ağa ihtiyaç duyar; örneğin bir paket kurmak. Yapılandırmanızda ağ erişimini açabilirsiniz:

sandbox_mode = "workspace-write"

[sandbox_workspace_write]
network_access = true

Yalnızca ihtiyaç duyduğunuz projeler için açın.

Onaylar

Onay politikası, aracının ne zaman durup sorduğunu belirler:

  • untrusted: Güvenilen listede olmayan komutları çalıştırmadan önce sorar

  • on-request: Bir görev, sandbox'ın izin verdiğinden daha fazla erişime ihtiyaç duyduğunda sorar

  • never: Asla sormaz

Sürüm kontrolüne alınmış projeler için workspace-write ve on-request iyi bir varsayılandır. Aracı projeniz içinde çalışır ve ötesine geçmeden önce sorar. Bir şeyler ters giderse Git geri dönüş yolu sunar.

--yolo bayrağı hem sandbox'ı hem onayları kapatır. Yalnızca konteyner veya sanal makine gibi atılabilir ortamlarda kullanın.

Kimlik bilgileri ve sırlar

Aracının çalıştırdığı komutlar kabuk ortamınızı devralır. API anahtarlarınız ortam değişkenlerindeyse, bu komutlar onları görebilir.

shell_environment_policy ile bunu sınırlayabilirsiniz:

[shell_environment_policy]
inherit = "core"
exclude = ["AWS_*", "*_TOKEN"]

core ayarı, HOME ve PATH gibi yalnızca temel değişkenleri geçirir ve exclude desenlerle eşleşen her şeyi çıkarır.

Dosyalar başka bir risktir. Aracı, read-only modda bile projenizdeki bir .env dosyasını okuyabilir. Barındırılan bir sağlayıcıyla, aracı ne okursa hepsi o sağlayıcının sunucularına gider.

Burada unutulmaması gereken, sandbox'ın zararı sınırladığı; ancak bunu bir güvence değil, emniyet ağı olarak görmeniz gerektiğidir.

Aracının kendi kendine çalışmasına izin vermeden önce, /status çalıştırın ve sandbox modunu ve onay politikasını kontrol edin.

Open Interpreter'ın Evrimi

pip install ile başlayan bir Open Interpreter yazısı bulursanız, yanlıştır diyemeyiz. Farklı bir projeyi anlatıyordur.

Orijinal Open Interpreter, 2023'te bir Python projesi olarak çıktı. Dil modellerinin makinenizde Python, JavaScript ve kabuk kodu çalıştırmasına izin veriyordu ve insanlar onu ChatGPT'nin Code Interpreter'ına açık kaynaklı bir alternatif olarak tanıyordu. Sonraki sürümler bilgisayar kontrolü ekledi; böylece model masaüstünüzle de çalışabiliyordu.

Mevcut ana proje, Codex tabanlı bir Rust yeniden yazımıdır. Genel bilgisayar kontrolü değil, kodlama aracılar ve kılıf öykünmesine odaklanır.

Python sürümü ortadan kaybolmadı. endolith/open-interpreter adresinde topluluk çatalı olarak devam eder.

Her iki sürüm de aynı adı, aynı GitHub depo geçmişini ve aynı interpreter komutunu kullanır; bu yüzden karıştırması kolaydır.

Ancak çok belirgin bir ayırt edici ipucu şudur:

  • pip install open-interpreter: Eski Python sürümü

  • curl veya PowerShell yükleyici: Mevcut Rust sürümü

Open Interpreter'ın Avantajları ve Sınırları

Open Interpreter her kurulum için doğru araç değildir. İşte mantıklı olduğu ve olmadığı yerler.

Avantajlar

  • Açık kaynak: Apache 2.0 lisansı altındadır; bu nedenle kod tabanının tamamını okuyabilir, denetleyebilir ve çatallayabilirsiniz

  • Model seçimi: Tek bir aracıdan barındırılan, açık ağırlıklı ve yerel modelleri kullanabilir ve oturum ortasında bunlar arasında geçiş yapabilirsiniz

  • Birden fazla aracı kılıfı: Çoğu diğer kodlama aracısının sunmadığı şekilde, bir modelin ayarlandığı performansa daha çok yaklaşırsınız

  • Terminal-yerel geliştirme: Mevcut kabuk ve Git iş akışınıza uyar ve exec modu betikler ve CI'da çalışır

  • Açık ve daha düşük maliyetli modeller: Proje bunların etrafında kuruludur; özel sağlayıcı kılavuzları ve eşleşen kılıflarla

  • Genişletilebilirlik: MCP, beceriler, kancalar, AGENTS.md, Agent Client Protocol ve Codex SDK geçersiz kılması diğer araçlara bağlanmanızı sağlar

Sınırlar

  • Model kalitesi değişkendir: Aracı, arkasındaki model kadar iyidir ve hiçbir kılıf çok adımlı bir görevi planlayamayan bir modeli düzeltemez

  • Yerel modeller ciddi donanım ister: Testlerimde, devstral-small-2 tek başına 26 GB bellek kullandı; kodlama aracısının ihtiyaç duyduğu büyük bağlam penceresinden önce

  • Kurulum daha fazla emek ister: Sağlayıcılar, bağlam pencereleri, kılıflar ve sandbox ayarlarını kendiniz yönetirsiniz. Ollama modelleri için kalan Codex markalaması ve meta veri uyarıları gibi pürüzler de vardır

  • Komut çalıştırma bir risktir: Sandbox ve onaylar riski azaltır; ancak ortadan kaldırmaz

  • Kod hâlâ inceleme ister: Testlerin geçmesi doğru bir düzeltmeyi garanti etmez; bu yüzden her diff'i okumalısınız

Sonuç

Open Interpreter, seçtiğiniz modelle (barındırılan, açık ağırlıklı veya kendi makinenizde çalışan) çalışan açık kaynaklı bir kodlama aracısıdır.

İş akışı basittir. Bir model ve kılıf seçer, aracıya bir proje gösterirsiniz; görev tamamlanana kadar incelemesine, düzenlemesine ve komutlar çalıştırmasına izin verirsiniz. Ardından işini gözden geçirirsiniz.

Kılıf öykünmesi onu rakiplerinden ayırır. Open Interpreter, her modeli tek bir aracı kurulumuna zorlamaz. Kurulumu modele uyarlar ve bu fark yaratabilir. İşin kalitesini model belirler; aracının neleri değiştirebileceğini izinler belirler. Kod tabanınıza herhangi bir değişiklik girmeden önce son kontrol sizin incelemenizdir.

Bir yapay zekâ mühendisi sertifikası almak istiyorsanız, Geliştiriciler için Yardımcı Yapay Zekâ Mühendisi eğitim yolumuza kaydolun ve kendi temponuzda yapay zekâ dünyasına geçiş yapın.

Dario Radečić

Yazar

Dario Radečić

Hırvatistan merkezli Kıdemli Veri Bilimci. 700’ün üzerinde yayımlanmış makaleyle 10 M+ görüntüleme elde eden, önde gelen bir teknoloji yazarı. TPOT ile Makine Öğrenimi Otomasyonu kitabının yazarı.

SSS

Open Interpreter ne için kullanılır?

Open Interpreter, projeleriniz üzerinde terminalden çalışan açık kaynaklı bir kodlama aracısıdır. Bir görevi tarif edersiniz; o da kodunuzu okur, dosyaları düzenler, komutlar çalıştırır ve görev tamamlanana kadar sonuçları kontrol eder. Geliştiriciler, hata düzeltmeleri, yeniden düzenlemeler, kod incelemeleri ve betikler ile CI hatlarında otomatik görevler için kullanır.

Open Interpreter'ı kullanmak ücretsiz mi?

Evet, Open Interpreter Apache 2.0 lisansı altında açık kaynaktır; bu nedenle aracın kendisi ücretsizdir. Bağladığınız model için yine de ödeme yaparsınız. Barındırılan sağlayıcılar belirteç başına veya abonelikle ücret alır; Ollama veya LM Studio üzerinden yerel modellerde belirteç başına maliyet yoktur ancak iyi donanım gerekir.

Open Interpreter'ı kullanmak güvenli mi?

Open Interpreter, komutları işletim sistemi düzeyinde bir sandbox içinde çalıştırır ve sandbox'ın izin verdiğinin ötesine geçmeden önce onay ister. Varsayılan olarak, workspace-write modu dosya yazmalarını proje klasörünüzle sınırlar ve ağ erişimini engeller. Sandbox riski azaltır ama ortadan kaldırmaz; bu yüzden /status ile izin ayarlarınızı kontrol edin ve commit'lemeden önce her değişikliği gözden geçirin.

Open Interpreter'ın Rust ve Python sürümleri arasındaki fark nedir?

Orijinal Python sürümü, dil modellerinin makinenizde kod çalıştırmasına ve bilgisayarınızı kontrol etmesine izin veriyordu ve pip install open-interpreter ile kuruluyordu. Mevcut sürüm, OpenAI'nin Codex'i temel alan, kodlama aracısına ve kılıf öykünmesine odaklanan bir Rust yeniden yazımıdır ve bağımsız bir betikle kurulur. Python sürümü topluluk çatalı olarak devam eder; bu nedenle her iki sürüm de bugün hâlâ geçerlidir.

Yerel Ollama modelim Open Interpreter'da neden döngüye giriyor veya takılıyor?

En yaygın neden, bağlam penceresinin çok küçük olmasıdır. Aracının sistem komutu, araç tanımları ve dosya içerikleri sığmaz; model görevin izini kaybeder. OLLAMA_CONTEXT_LENGTH'i en az 65536 olarak ayarlayın ve ollama ps ile değeri doğrulayın. Bundan sonra bellek kullanımı artıp azalmaya devam ediyorsa, model makineniz için çok büyüktür; bu durumda qwen3-coder:30b veya gpt-oss:20b gibi daha küçük bir modele geçin.

Konular