Yerel AI Modellerini VS Code’da Continue ile Kullanma: Çoklu Model Desteği

Bulut tabanlı yapay zeka hizmetlerinin maliyetleri ve veri gizliliği endişeleri sizi düşündürüyor mu? Peki ya en sevdiğiniz geliştirme ortamı olan VS Code’dan ayrılmadan, birden fazla yapay zeka modelini yerel olarak çalıştırmak ve bunlar arasında kolayca geçiş yapmak mümkün olsa? İşte bu makale, tam da bu ihtiyacınıza odaklanıyor: Continue eklentisi ile yerel AI modellerini VS Code’da nasıl kullanacağınızı, farklı modeller arasında geçiş yapmanın inceliklerini ve geliştirme süreçlerinizi nasıl optimize edebileceğinizi adım adım keşfedeceksiniz.

Günümüz yazılım geliştirme dünyasında yapay zeka, kod yazmaktan hata ayıklamaya, dokümantasyon oluşturmaktan karmaşık problemleri çözmeye kadar pek çok alanda vazgeçilmez bir yardımcı haline geldi. Ancak çoğu geliştirici, OpenAI’nin GPT modelleri veya Google’ın Gemini gibi bulut tabanlı servislere bağımlı kalıyor. Bu bağımlılık, beraberinde veri gizliliği endişeleri, yüksek API maliyetleri ve sürekli internet bağlantısı gereksinimi gibi bazı dezavantajları getiriyor. İşte tam bu noktada “yerel AI” kavramı devreye giriyor.

Yerel AI, yapay zeka modellerini kendi bilgisayarınızda veya sunucularınızda çalıştırma yeteneğidir. Bu yaklaşım, verilerinizin yerel ağınızda kalmasını sağlayarak gizlilik konusunda önemli bir avantaj sunar. Ayrıca, bulut API ücretlerinden tasarruf etmenizi ve internet bağlantınız olmasa bile AI destekli araçları kullanabilmenizi sağlar. Yerel AI çözümleri, özellikle hassas verilerle çalışan veya yoğun AI kullanımı olan ekipler için stratejik bir tercih haline gelmiştir.

Peki, bu yerel AI gücünü VS Code gibi popüler bir geliştirme ortamına nasıl entegre edebiliriz? Cevap: Continue eklentisi. Continue, VS Code için özel olarak tasarlanmış, açık kaynaklı bir yapay zeka asistanıdır. Geliştiricilerin, kod düzenleyicisinden ayrılmadan AI modelleriyle etkileşime geçmesine olanak tanır. Continue’nun en çarpıcı özelliklerinden biri, yalnızca bulut tabanlı modellere değil, aynı zamanda Ollama, LM Studio gibi yerel sunucular aracılığıyla çalıştırılan açık kaynaklı modellere de tam destek vermesidir. Bu sayede, Llama 3, CodeLlama, Mistral gibi popüler modelleri kendi bilgisayarınızda çalıştırırken, Continue’nun sunduğu gelişmiş arayüz ve özelliklerden faydalanabilirsiniz.

Continue’u kullanmanın başlıca nedenleri şunlardır:

• Gizlilik ve Güvenlik: Hassas kodlarınızı veya şirket içi verilerinizi üçüncü taraf AI servisleriyle paylaşmak zorunda kalmazsınız. Her şey yerel makinenizde kalır.
• Maliyet Etkinliği: API çağrısı başına ödeme yapma derdi ortadan kalkar. Donanım maliyeti başlangıçta olsa da, uzun vadede önemli tasarruflar sağlar.
• Çevrimdışı Çalışma: İnternet bağlantısı olmasa bile AI asistanınız her zaman yanınızdadır. Seyahat eden geliştiriciler veya kısıtlı ağ erişimi olan ortamlar için idealdir.
• Esneklik ve Özelleştirme: Farklı görevler için farklı modelleri kullanabilir, hatta kendi ince ayarlı (fine-tuned) modellerinizi entegre edebilirsiniz. Bu makalenin ana odak noktası olan çoklu model desteği, bu esnekliğin temelini oluşturur.
• Geliştirici Odaklı Deneyim: Kod tamamlama, hata ayıklama, kod refactoring, test senaryosu üretimi gibi geliştirme süreçlerine özel optimize edilmiş özellikler sunar. VS Code’un doğal bir uzantısı gibi hissettirir.

Sonuç olarak, Continue eklentisi, yerel yapay zeka modellerinin gücünü VS Code’a taşıyarak, geliştiricilere daha güvenli, maliyet etkin ve esnek bir AI destekli geliştirme deneyimi sunar. Şimdi gelin, bu güçlü ikilinin kurulum ve yapılandırma adımlarına geçelim.

VS Code ve Continue Kurulumu Adım Adım Nasıl Yapılır?

Yerel AI modellerini VS Code içinde Continue eklentisi ile kullanmaya başlamak için birkaç temel adımı takip etmemiz gerekiyor. Bu adımlar, VS Code’un kendisinden başlayarak, Continue eklentisinin yüklenmesi ve yerel modelleri çalıştırmak için gerekli altyapının hazırlanmasına kadar uzanır. Okuyucuyu sıfırdan düşünerek, her adımı detaylı bir şekilde açıklayacağız.

1. VS Code Kurulumu (Eğer Kurulu Değilse)

Eğer henüz Visual Studio Code’u bilgisayarınıza kurmadıysanız, öncelikle bu adımı tamamlamanız gerekmektedir. VS Code, geliştiriciler arasında oldukça popüler, hafif ve güçlü bir kod düzenleyicidir.

1. VS Code’un resmi web sitesine gidin: code.visualstudio.com
2. İşletim sisteminize (Windows, macOS, Linux) uygun sürümü indirin.
3. İndirilen kurulum dosyasını çalıştırın ve ekrandaki talimatları izleyerek kurulumu tamamlayın. Genellikle varsayılan ayarları kabul etmek yeterlidir.

2. Continue Eklentisinin VS Code’a Kurulumu

VS Code kurulduktan sonra, sıra Continue eklentisini eklemeye geliyor. Bu eklenti, yerel AI modellerinizle VS Code içinde etkileşim kurmanızı sağlayacak ana köprüdür.

1. VS Code’u açın.
2. Sol kenar çubuğundaki “Uzantılar” (Extensions) simgesine tıklayın (veya Ctrl+Shift+X / Cmd+Shift+X kısayolunu kullanın).
3. Arama kutusuna “Continue” yazın.
4. “Continue – an open-source alternative to GitHub Copilot” başlıklı eklentiyi bulun.
5. Eklentinin yanındaki “Yükle” (Install) düğmesine tıklayın. Kurulum tamamlandığında, VS Code’un sol kenar çubuğunda Continue’nun sohbet simgesi (genellikle bir robot veya sohbet balonu) belirecektir.

3. Yerel AI Model Sunucusunun Kurulumu: Ollama ile Tanışın

Continue eklentisi bir arayüz sağlarken, yerel AI modellerini gerçekten çalıştıracak bir sunucuya ihtiyacımız var. Bu makalede, kurulumu ve kullanımı nispeten kolay olduğu için Ollama‘yı tercih edeceğiz. Ollama, açık kaynaklı büyük dil modellerini (LLM’ler) yerel makinenizde çalıştırmayı inanılmaz derecede basitleştiren harika bir araçtır. Alternatif olarak LM Studio veya Jan gibi araçları da kullanabilirsiniz, ancak süreç benzer olacaktır.

1. Ollama’nın resmi web sitesine gidin: ollama.com
2. İşletim sisteminize uygun sürümü indirin (Windows, macOS, Linux).
3. İndirilen kurulum dosyasını çalıştırın ve talimatları izleyerek Ollama’yı yükleyin. Kurulum tamamlandığında, Ollama arka planda bir servis olarak çalışmaya başlayacaktır.

4. Yerel AI Modeli İndirme

Ollama’yı kurduktan sonra, çalıştırmak istediğiniz AI modelini indirmeniz gerekiyor. Ollama, geniş bir model kütüphanesine sahiptir. Kod üretimi için popüler seçeneklerden biri CodeLlama veya daha genel amaçlı bir model olan Llama 3’tür. Örneğin, Llama 3 modelini indirmek için bir terminal (komut istemcisi) açın ve aşağıdaki komutu çalıştırın:

ollama run llama3
    

Bu komut, Llama 3 modelinin en son sürümünü otomatik olarak indirip çalıştıracaktır. İlk çalışmada modelin boyutu nedeniyle biraz zaman alabilir. İndirme tamamlandıktan sonra, Ollama modeli yerel olarak saklayacak ve istediğiniz zaman kullanıma hazır hale getirecektir. İsterseniz farklı modelleri de aynı şekilde indirebilirsiniz, örneğin:

ollama run codellama
ollama run mistral
    

Her modelin kendine özgü yetenekleri ve boyutları vardır. Daha küçük modeller genellikle daha hızlı çalışır ancak daha büyük modeller kadar karmaşık görevlerde başarılı olmayabilir. Seçiminizi projenizin gereksinimlerine göre yapmalısınız.

Bu adımlarla birlikte, yerel AI ortamınızın temelini atmış oldunuz. VS Code, Continue eklentisi ve Ollama ile birlikte indirdiğiniz modeller artık sizin emrinizde. Bir sonraki bölümde, Continue eklentisini bu yerel modellerle nasıl yapılandıracağımızı ve ilk yapay zeka etkileşimlerimizi nasıl başlatacağımızı öğreneceğiz.

Yerel AI Modellerini Continue ile Yapılandırma ve İlk Kullanım

Kurulumları tamamladığımıza göre, şimdi Continue eklentisini Ollama üzerinden indirdiğimiz yerel AI modelleriyle nasıl konuşturacağımızı öğrenme zamanı. Bu bölüm, Continue'nun yapılandırma dosyasını düzenlemeyi, modellerinizi tanımlamayı ve ilk yapay zeka destekli görevlerinizi gerçekleştirmeyi kapsayacaktır.

1. Continue Yapılandırma Dosyasına Erişim

Continue eklentisi, tüm ayarlarını ve model tanımlamalarını özel bir JSON dosyasında saklar. Bu dosyaya erişmek için VS Code'da Continue panelini açın (sol kenar çubuğundaki simgesine tıklayın) ve ardından sağ üst köşedeki ayarlar (dişli çark) simgesine tıklayın. Açılan menüden "Edit config.json" seçeneğini seçin. Bu işlem, VS Code'da ~/.continue/config.json (veya işletim sisteminize göre benzer bir yol) dosyasını açacaktır.

2. Ollama Modellerini Yapılandırma

config.json dosyası, Continue'nun hangi AI modellerini kullanacağını ve bu modellere nasıl erişeceğini tanımladığımız yerdir. Varsayılan olarak, bu dosyada OpenAI veya diğer bulut tabanlı modeller için örnek ayarlar bulunabilir. Bizim amacımız, Ollama üzerinden indirdiğimiz yerel modelleri buraya eklemektir.

Aşağıdaki gibi bir yapıya sahip olması gereken bir config.json içeriği göreceksiniz. Biz models dizisini düzenleyeceğiz:

{
  "models": [
    {
      "name": "llama3",
      "provider": "ollama",
      "model": "llama3",
      "apiKey": ""
    },
    {
      "name": "codellama",
      "provider": "ollama",
      "model": "codellama",
      "apiKey": ""
    }
  ],
  "slashCommands": [],
  "policy": "always",
  "ide": "vscode"
}
    

Yukarıdaki örnekte:

• models: Continue'un kullanabileceği tüm AI modellerini içeren bir dizidir.
• Her bir model nesnesi içinde:
  • name: Continue arayüzünde modelin görünen adıdır (örneğin "llama3", "codellama"). Bu adı istediğiniz gibi belirleyebilirsiniz.
  • provider: Modelin hangi servis sağlayıcı tarafından sunulduğunu belirtir. Yerel Ollama modelleri için her zaman "ollama" olmalıdır.
  • model: Ollama'da indirdiğiniz modelin tam adıdır (örneğin ollama run llama3 komutunda kullandığınız "llama3").
  • apiKey: Ollama yerel bir servis olduğu için buna ihtiyaç duymaz. Boş bırakabilirsiniz.

Bu yapılandırmayı kaydedin. Continue eklentisi genellikle dosyayı kaydettiğinizde otomatik olarak güncellemeleri algılar. Eğer algılamazsa, VS Code'u yeniden başlatmanız gerekebilir.

3. Continue Arayüzünde Model Seçimi

Yapılandırma dosyasını kaydettikten sonra, Continue panelinde sol üst köşede bir açılır menü (dropdown) göreceksiniz. Bu menüye tıkladığınızda, config.json dosyasında tanımladığınız "name" değerleriyle (örneğin "llama3", "codellama") modellerinizin listelendiğini göreceksiniz. Buradan, o an kullanmak istediğiniz modeli seçebilirsiniz.

4. İlk Etkileşim: Bir Kod Parçacığı Oluşturma

Şimdi bir örnekle Continue'nun nasıl çalıştığını görelim. Diyelim ki Python'da bir dizi ortalaması hesaplayan bir fonksiyon yazmak istiyorsunuz. Şu adımları izleyebilirsiniz:

1. VS Code'da yeni bir Python dosyası (örneğin app.py) açın.
2. Continue panelinden "llama3" modelini seçtiğinizden emin olun.
3. Continue sohbet kutusuna aşağıdaki gibi bir istek yazın:

   
   Python'da bir liste içindeki sayıların ortalamasını bulan bir fonksiyon yaz. Fonksiyonun adı calculate_average olsun ve bir örnek kullanımını da ekle.
               

4. Enter tuşuna basın. Continue, seçtiğiniz model (llama3) aracılığıyla bu isteği işleyecek ve birkaç saniye içinde bir cevap üretecektir.

Ollama'nın CPU veya GPU gücüne bağlı olarak yanıt süresi değişebilir. Üretilen yanıt genellikle aşağıdaki gibi olacaktır:

def calculate_average(numbers):
    """
    Verilen bir sayı listesinin ortalamasını hesaplar.

    Args:
        numbers (list): Sayılardan oluşan bir liste.

    Returns:
        float: Sayıların ortalaması. Eğer liste boşsa 0.0 döndürür.
    """
    if not numbers:
        return 0.0
    return sum(numbers) / len(numbers)

# Örnek kullanım
my_list = [10, 20, 30, 40, 50]
average = calculate_average(my_list)
print(f"Liste: {my_list}")
print(f"Ortalama: {average}")

# Boş liste örneği
empty_list = []
average_empty = calculate_average(empty_list)
print(f"Boş Liste: {empty_list}")
print(f"Ortalama (boş liste): {average_empty}")
    

Continue'nun size verdiği yanıtı direkt olarak kod dosyanıza kopyalayıp yapıştırabilir veya sohbet arayüzündeki ilgili düğmeleri kullanarak mevcut kodunuza ekleyebilirsiniz. Bu etkileşim, Continue'nun yerel AI modelleriyle ne kadar entegre ve kullanışlı olduğunu gösteriyor.

Bu temel yapılandırma ve kullanım adımlarıyla, artık yerel AI modellerinizi VS Code'da etkin bir şekilde kullanmaya hazırsınız. Bir sonraki bölümde, Continue'nun en güçlü özelliklerinden biri olan çoklu model desteğini nasıl kullanacağımıza ve farklı görevler için farklı modeller arasında nasıl geçiş yapacağımıza odaklanacağız.

Çoklu Model Desteği: Farklı Modeller Arasında Geçiş Nasıl Yapılır?

Yapay zeka modelleri dünyası, tek bir modelin her işi mükemmel yaptığı bir yer değildir. Bazı modeller kod oluşturmada çok başarılıyken, diğerleri doğal dil anlama, yaratıcı metin yazma veya karmaşık mantık yürütme konularında daha iyi performans gösterebilir. İşte bu noktada Continue eklentisinin çoklu model desteği devreye giriyor. Geliştiricilere, farklı görevler için en uygun AI modelini seçme esnekliği sunarak verimliliği maksimize eder.

Neden Çoklu Model Desteğine İhtiyaç Duyarız?

Çoklu model stratejisi benimsemenin başlıca nedenleri şunlardır:

• Göreve Özgü Optimizasyon: CodeLlama gibi modeller kod üretimi ve analizi için özel olarak eğitilmiştir. Genel amaçlı Llama 3 veya Mistral modelleri ise daha geniş yelpazede metin tabanlı görevlerde daha iyi olabilir. Doğru modeli doğru görev için kullanmak, hem çıktı kalitesini artırır hem de kaynakları daha verimli kullanır.
• Performans ve Hız: Daha küçük, göreve özel modeller, büyük genel modellerden daha hızlı yanıt verebilir. Bu, özellikle anlık kod tamamlama veya hızlı sorgulamalar için önemlidir.
• Maliyet (Bulut Modelleri İçin): Her ne kadar yerel modellerde bu durum daha az hissedilse de, bulut tabanlı modellerle çalışırken farklı modellerin farklı maliyet yapıları olabilir. En uygun maliyetli ve performanslı modeli seçmek kritik olabilir.
• Deneme ve Karşılaştırma: Farklı modelleri aynı arayüz üzerinden kolayca deneyebilir ve hangisinin sizin iş akışınıza veya projenize en uygun olduğunu hızlıca belirleyebilirsiniz.

config.json İçinde Birden Fazla Model Tanımlama

Önceki bölümde, config.json dosyasına iki farklı Ollama modelini (llama3 ve codellama) nasıl ekleyeceğimizi görmüştük. İşte tekrar, hatırlatma amacıyla:

{
  "models": [
    {
      "name": "Llama 3 (Genel Amaçlı)",
      "provider": "ollama",
      "model": "llama3"
    },
    {
      "name": "CodeLlama (Kod Odaklı)",
      "provider": "ollama",
      "model": "codellama"
    },
    {
      "name": "Mistral (Hızlı & Yetenekli)",
      "provider": "ollama",
      "model": "mistral"
    }
  ],
  // ... diğer ayarlar
}
    

Burada önemli olan, her modele açık ve anlaşılır bir "name" vermektir, böylece Continue arayüzünde hangi modelin ne işe yaradığını kolayca anlayabilirsiniz. Örneğin, "Llama 3 (Genel Amaçlı)" gibi bir adlandırma, modelin yetenekleri hakkında bilgi verir.

Continue Arayüzünden Modeller Arası Geçiş Yapma

config.json dosyasını kaydettikten sonra, Continue eklentisi panelini açın. Panelde, sohbet kutusunun hemen üstünde veya sol üst köşede, aktif olarak kullanılan modelin adını gösteren bir açılır menü (dropdown) göreceksiniz. Bu menüye tıklayarak, config.json dosyasında tanımladığınız tüm modelleri bir liste halinde görebilirsiniz. Buradan, o anki göreviniz için en uygun modeli seçmeniz yeterlidir.

Örneğin, bir API entegrasyonu için kod yazdırırken "CodeLlama (Kod Odaklı)" modelini seçebilir, ardından README dosyası için açıklama metni yazdırırken "Llama 3 (Genel Amaçlı)" modeline geçebilirsiniz. Bu geçiş, tek bir tıklama ile anında gerçekleşir ve herhangi bir yeniden başlatma gerektirmez.

Vaka Analizi: Farklı Görevler İçin Çoklu Model Kullanımı

Şimdi gerçek bir senaryo üzerinden çoklu model kullanımının avantajlarını inceleyelim:

Senaryo: Bir Web Uygulaması Geliştirme

1. HTML Yapısı Oluşturma (Llama 3 ile):

   Grev: Bir web sayfasının temel HTML yapısını, Bootstrap entegrasyonu ile birlikte oluşturmak.

   Seçilen Model: Llama 3 (Genel Amaçlı)

   Neden: Llama 3, genel metin üretimi, stil kılavuzlarını anlama ve farklı teknolojileri birleştirme konusunda daha yeteneklidir. HTML yapısı oluşturmak, saf kod mantığından çok, metinsel talimatları takibe daha yakındır.

   Llama 3, bu isteğe uygun, iyi yorumlanmış ve Bootstrap sınıflarını içeren bir HTML yapısı üretecektir.

2. JavaScript Fonksiyonu Yazma (CodeLlama ile):

   Grev: Oluşturulan HTML yapısındaki bir formun gönderimini işleyecek, giriş verilerini doğrulayacak ve bir API'ye gönderecek bir JavaScript fonksiyonu yazmak.

   Seçilen Model: CodeLlama (Kod Odaklı)

   Neden: CodeLlama, kod üretimi, sentaks doğruluğu, hata işleme ve belirli programlama dillerine özgü optimizasyonlar konusunda çok daha güçlüdür. JavaScript form işleme, doğrudan kod mantığıyla ilgilidir.

   
   // Mevcut form elemanlarını kullanarak, bir API'ye POST isteği gönderen ve yanıtı işleyen bir JavaScript fonksiyonu yaz. Veri doğrulamasını da içer.
               

   CodeLlama, API isteği, form doğrulama mantığı ve hata işleme içeren sağlam bir JavaScript kodu üretecektir.

3. Dokümantasyon ve Açıklama Yazma (Mistral ile):

   Grev: Yazılan JavaScript fonksiyonu için bir JSDoc yorumu ve projenin genel README dosyasına bu fonksiyonun kullanımını açıklayan bir paragraf eklemek.

   Seçilen Model: Mistral (Hızlı & Yetenekli)

   Neden: Mistral, hızlı ve özlü metin üretimi, özetleme ve açıklayıcı yazım konusunda başarılıdır. Dokümantasyon, teknik metinleri anlaşılır bir dille ifade etmeyi gerektirir.

   
   // Bu JavaScript fonksiyonunun ne işe yaradığını, parametrelerini ve dönüş değerini açıklayan bir JSDoc yorumu oluştur. Ayrıca projenin README dosyasına eklemek için kısa bir açıklama paragrafı yaz.
               

   Mistral, hem fonksiyon için doğru formatta bir JSDoc bloğu hem de README için kısa ve açıklayıcı bir paragraf üretecektir.

Bu senaryo, tek bir geliştirme oturumunda dahi farklı modellerin nasıl etkili bir şekilde kullanılabileceğini göstermektedir. Continue'nun çoklu model desteği, geliştiricilere daha dinamik, verimli ve yüksek kaliteli bir yapay zeka destekli geliştirme deneyimi sunar.

Gerçek Dünya Senaryoları ve Vaka Analizleri: Continue ile Verimliliği Artırma

Continue eklentisinin yerel AI modelleriyle sunduğu çoklu model desteği, geliştiricilerin günlük iş akışlarında karşılaştıkları pek çok zorluğa pratik çözümler sunar. Bu bölümde, gerçek dünya senaryoları ve vaka analizleri aracılığıyla Continue'un verimliliği nasıl artırdığını somut örneklerle inceleyeceğiz.

Vaka Analizi 1: Kod Refactoring ve Optimizasyon

Senaryo: Büyük ve eski bir kod tabanında, performansı düşük olan veya okunabilirliği zayıf karmaşık bir fonksiyonu yeniden düzenlemek (refactor etmek) gerekiyor. Manuel olarak bu süreci tamamlamak zaman alıcı ve hata yapmaya açık bir süreçtir.

Continue ile Çözüm:

1. Model Seçimi: CodeLlama (Kod Odaklı) seçilir, çünkü bu model kod analizi ve üretimi için özel olarak eğitilmiştir.
2. Problemin Tanımlanması: İlgili fonksiyonun bulunduğu kodu VS Code'da açın. Continue sohbet panelinde, fonksiyonu seçili hale getirin veya doğrudan metin kutusuna kopyalayın. Şuna benzer bir komut verin:

   
   Bu Python fonksiyonunu daha okunabilir, modüler ve performanslı hale getirerek refactor et. Özellikle döngüleri ve veri yapılarını optimize etme potansiyelini değerlendir.
               

3. AI Yanıtı: CodeLlama, orijinal fonksiyonu analiz eder ve genellikle aşağıdaki gibi bir yanıt üretir:
   • Daha iyi değişken adlandırmaları.
   • Daha optimize edilmiş algoritmalar (örneğin, liste birleştirmeleri yerine daha verimli yöntemler).
   • Fonksiyonu daha küçük, tek sorumluluklu alt fonksiyonlara bölme önerileri.
   • Muhtemel performans iyileştirmelerini açıklayan yorumlar.

   Örnek bir eski kod ve CodeLlama'nın refactor edilmiş hali:

   
   # Eski Kod
   def process_data_old(data_list):
       processed = []
       for item in data_list:
           if item > 0:
               processed.append(item * 2)
       return processed
   
   # Continue'dan gelen Refactor Önerisi (CodeLlama)
   def filter_and_double_positive_numbers(numbers):
       """
       Pozitif sayıları filtreler ve her birini ikiyle çarpar.
   
       Args:
           numbers (list): İşlenecek sayı listesi.
   
       Returns:
           list: Filtrelenmiş ve çarpılmış sayıların listesi.
       """
       return [num * 2 for num in numbers if num > 0] # Liste anlama (list comprehension) ile daha verimli
               

4. Uygulama ve İterasyon: Önerilen kodu gözden geçirin, gerekli ayarlamaları yapın ve kod tabanınıza entegre edin. İhtiyaç halinde, daha spesifik sorular sorarak veya farklı refactoring stratejileri deneyerek süreci yineleyebilirsiniz.

Fayda: Refactoring sürecini hızlandırır, kod kalitesini artırır, potansiyel hataları azaltır ve geliştiricinin daha stratejik görevlere odaklanmasını sağlar.

Vaka Analizi 2: Yeni Özellik Geliştirme ve API Entegrasyonu

Senaryo: Mevcut bir Node.js backend uygulamasına yeni bir endpoint eklenmesi gerekiyor. Bu endpoint, harici bir REST API'den veri çekecek, işleyecek ve istemciye döndürecek. Geliştirici, API'nin dokümantasyonunu okumak ve boilerplate kodu yazmak yerine süreci hızlandırmak istiyor.

Continue ile Çözüm:

1. Model Seçimi: Yine CodeLlama (Kod Odaklı) veya Llama 3 (Genel Amaçlı) gibi geniş kapsamlı kod yeteneklerine sahip bir model seçilebilir.
2. Gereksinimleri Belirtme: Continue sohbet kutusuna gereksinimleri açıklayın. Örneğin:

   
   Express.js kullanarak /api/products adresinde bir GET endpoint'i oluştur. Bu endpoint, https://api.example.com/items adresinden ürün verilerini çekmeli, sadece name ve price alanlarını içeren bir nesne dizisi olarak formatlamalı ve istemciye JSON olarak dönmeli. Hata yönetimini de ekle.
               

3. AI Yanıtı: Model, Express.js için gerekli rotayı, axios veya node-fetch gibi bir kütüphane kullanarak harici API çağrısını, veri işleme mantığını ve hata yakalama bloklarını içeren bir kod parçası üretecektir.

   
   const express = require('express');
   const axios = require('axios'); // 'npm install axios' ile yüklenmeli
   const router = express.Router();
   
   router.get('/products', async (req, res) => {
       try {
           const response = await axios.get('https://api.example.com/items');
           const products = response.data.map(item => ({
               name: item.productName, // API'den gelen gerçek alan adlarını buraya yazın
               price: item.itemPrice
           }));
           res.json(products);
       } catch (error) {
           console.error('Harici API çağrısı hatası:', error.message);
           res.status(500).json({ message: 'Ürünler alınamadı', error: error.message });
       }
   });
   
   module.exports = router;
               

4. Entegrasyon ve Test: Üretilen kodu projenize entegre edin, API'nin gerçek alan adlarını kontrol edin ve test edin. Continue, hızlı başlangıçlar ve boilerplate kod üretimi için mükemmel bir yardımcıdır.

Fayda: Yeni özelliklerin geliştirilme süresini önemli ölçüde kısaltır, sıkıcı ve tekrarlayan kod yazımını ortadan kaldırır ve geliştiricinin iş mantığına odaklanmasına olanak tanır.

Vaka Analizi 3: Hata Ayıklama ve Çözüm Önerileri

Senaryo: Uygulamanızda beklenmedik bir hata oluştu ve konsol çıktısı veya log kayıtları karmaşık. Hatanın nedenini bulmak ve çözmek için saatler harcamak yerine, AI'dan yardım almak istiyorsunuz.

Continue ile Çözüm:

1. Model Seçimi: Hata mesajının ve kodun diline bağlı olarak CodeLlama (Kod Odaklı) veya Llama 3 (Genel Amaçlı) kullanılabilir.
2. Problemi Sunma: Hata mesajını, ilgili kod bloğunu ve hatanın meydana geldiği bağlamı Continue sohbet kutusuna yapıştırın. Örneğin:

   
   Bu JavaScript kodunda bir TypeError: Cannot read properties of undefined (reading 'id') hatası alıyorum. Hata, processUser fonksiyonu çağrıldığında oluşuyor. Fonksiyon ve hata mesajı aşağıda:
   
   // Kod
   function processUser(user) {
       console.log(user.id);
       // ... diğer işlemler
   }
   
   // Hata mesajı
   TypeError: Cannot read properties of undefined (reading 'id')
       at processUser (app.js:10:20)
       at Object. (app.js:15:1)
       at Module._compile (node:internal/modules/cjs/loader:1105:14)
   // ...
   
   
   
   Bu hatayı neden alıyorum ve nasıl çözebilirim?
   
               
           

3. AI Yanıtı: Model, hatayı analiz eder ve büyük olasılıkla user nesnesinin undefined veya null olabileceğini belirten bir açıklama yapar. Çözüm olarak, fonksiyonun başında bir kontrol eklemeyi veya çağıran kodun user argümanını doğru bir nesne ile sağlamasını önerecektir.

   
   Bu hata (TypeError: Cannot read properties of undefined (reading 'id')), processUser fonksiyonuna user parametresi olarak undefined veya null bir değer gönderildiğinde ortaya çıkar. Fonksiyon, user nesnesinin bir id özelliğine sahip olduğunu varsayıyor, ancak user tanımlı değil.
   
   Çözüm: Fonksiyonun başında user parametresinin geçerli olup olmadığını kontrol edebilirsiniz. Örneğin:
   
   function processUser(user) {
       if (!user) {
           console.error("Hata: Kullanıcı nesnesi tanımsız veya boş.");
           return; // İşlemi durdur veya varsayılan bir değer kullan
       }
       console.log(user.id);
       // ... diğer işlemler
   }
   
   
   
   Veya processUser fonksiyonunu çağırdığınız yerden, user değişkeninin her zaman geçerli bir nesne olduğundan emin olun.
   
               
           

4. Doğrulama ve Onarım: AI'nın önerisini uygulayın, kodu düzeltin ve tekrar test edin. Bu süreç, karmaşık hata mesajlarını anlamanıza ve hızlıca çözüm bulmanıza yardımcı olur.

Fayda: Hata ayıklama süresini dramatik şekilde kısaltır, geliştiricinin problem çözme becerilerini destekler ve hata kaynaklarını daha hızlı tespit etmeye yardımcı olur.

Bu vaka analizleri, Continue'nun yerel AI modelleriyle entegrasyonunun, bir geliştiricinin günlük iş akışında ne kadar değerli bir araç olabileceğini göstermektedir. Kod yazmaktan hata ayıklamaya kadar geniş bir yelpazede, Continue verimliliği artırmanın ve geliştirme sürecini daha keyifli hale getirmenin anahtarıdır.

İleri Düzey Kullanım İpuçları ve Performans Optimizasyonu

Continue eklentisini ve yerel AI modellerini temel seviyede kullanmayı öğrendik. Şimdi, deneyimli kullanıcılar için bazı ileri düzey ipuçları ve performans optimizasyon stratejilerine göz atalım. Bu bilgiler, AI destekli geliştirme deneyiminizi daha da zenginleştirecek ve karşılaştığınız potansiyel sorunlara çözümler sunacaktır.

1. Prompt Mühendisliği İpuçları

Yapay zeka modellerinden en iyi sonuçları almak, doğru "prompt"ları (istemleri) yazmaktan geçer. Etkili prompt mühendisliği, AI'dan istediğiniz çıktıyı daha hızlı ve doğru bir şekilde almanızı sağlar.

• Net ve Spesifik Olun: Ne istediğinizi tam olarak belirtin. Belirsiz ifadelerden kaçının. "Bana kod yaz" yerine "Python'da bir REST API'den veri çeken ve Pandas DataFrame'e dönüştüren bir fonksiyon yaz" gibi.
• Bağlam Sağlayın: AI'ın mevcut kodunuzu veya projenizin genel yapısını anlaması için yeterli bağlamı verin. Mevcut kod parçalarını, dosya yapılarını veya hata mesajlarını prompt'unuza dahil edin.
• Formatı Belirtin: Çıktının hangi formatta olmasını istediğinizi söyleyin. "JSON formatında bir örnek yanıt ver", "Markdown tablosu olarak sonuçları göster", "JSDoc yorumu ekle" gibi.
• Örnekler Verin (Few-shot prompting): Eğer AI'dan belirli bir stilde veya karmaşık bir formatta çıktı istiyorsanız, bir veya iki örnek vererek AI'ın ne beklediğinizi daha iyi anlamasını sağlayabilirsiniz.
• Kısıtlamalar Belirtin: "Sadece Python 3.9 kullan", "üçüncü parti kütüphane kullanma", "bu fonksiyon 10 satırı geçmesin" gibi kısıtlamalar ekleyin.
• İteratif Yaklaşım: İlk prompt'unuzdan mükemmel bir yanıt beklemeyin. Yanıtı değerlendirin, eksiklerini veya hatalarını belirtin ve daha iyi bir sonuç için prompt'unuzu iyileştirin.

2. Özelleştirilmiş Modeller ve Fine-tuning'e Kısa Bir Bakış

Yerel AI'nın en büyük avantajlarından biri, açık kaynaklı modelleri kendi verilerinizle ince ayar (fine-tuning) yapabilme potansiyelidir. Bu, modelin belirli bir görevde veya belirli bir kod tabanında çok daha iyi performans göstermesini sağlar. Örneğin, şirketinizin dahili kodlama standartlarına veya belirli bir dikey alana özel jargonuna uygun bir model oluşturabilirsiniz.

Ollama, doğrudan fine-tuning yeteneği sunmasa da, Hugging Face gibi platformlardan ince ayarlı modelleri indirip Ollama ile çalıştırabilirsiniz. Kendi fine-tuned modelinizi oluşturmak, daha gelişmiş bir konudur ve genellikle özel veri setleri ve belirli bir miktar GPU kaynağı gerektirir.

3. GPU Kullanımı ve Performansı Artırma

Büyük dil modelleri, özellikle yerel olarak çalıştırıldığında yoğun GPU (Grafik İşlem Birimi) kaynakları gerektirebilir. Eğer bilgisayarınızda bir NVIDIA GPU varsa (veya Apple Silicon çiplerinde Metal desteği varsa), Ollama ve diğer yerel AI sunucuları bu GPU'yu kullanarak modelin yanıt süresini önemli ölçüde hızlandırabilir.

• GPU Sürücüleri: GPU'nuz için en güncel sürücülerin kurulu olduğundan emin olun.
• Ollama ve GPU: Ollama, kurulum sırasında otomatik olarak GPU'nuzu algılamaya çalışır. Ancak, bazen manuel olarak yapılandırma gerekebilir. Ollama'nın dökümantasyonunu kontrol ederek GPU kullanımını optimize etme hakkında bilgi edinin.
• Model Boyutu: İhtiyaçlarınıza uygun en küçük modeli seçmeye çalışın. Daha küçük modeller daha az GPU belleği ve işlem gücü gerektirir. Örneğin, Llama 3'ün 8B (8 milyar parametre) sürümü, 70B sürümünden çok daha hafif çalışacaktır.
• RAM Yükseltmesi: Eğer GPU'nuz yeterli değilse veya CPU üzerinde çalışıyorsanız, yeterli RAM (Bellek) olması da performansı artırabilir. LLM'ler önemli miktarda belleği önbelleğe alır.

4. Klavye Kısayolları ve Gelişmiş Continue Özellikleri

Continue, geliştirme akışınızı hızlandırmak için bir dizi klavye kısayolu ve gelişmiş özellik sunar:

• Sohbeti Başlatma: Varsayılan olarak, VS Code'da bir kod bloğunu seçip Cmd/Ctrl+I tuşlarına basarak Continue sohbetini doğrudan seçili kodla başlatabilirsiniz.
• Otomatik Tamamlama: Yazdığınız kod içinde otomatik tamamlama önerileri almak için, Continue'nun belirli modelleri kullanacak şekilde ayarlandığından emin olun. Bu, anında kod parçacıkları veya satır tamamlama önerileri sunabilir.
• Slash Komutları: Continue sohbet kutusuna / yazarak bir dizi önceden tanımlanmış komutu görebilirsiniz (örneğin /edit, /fix, /test). Bu komutlar, belirli görevler için AI'dan daha hedeflenmiş yardımlar almanızı sağlar. Kendi özel slash komutlarınızı da config.json dosyasında tanımlayabilirsiniz.
• Sürüm Kontrolü Entegrasyonu: Continue, yaptığınız değişiklikleri kolayca gözden geçirmenize ve sürüm kontrol sisteminizle entegre etmenize yardımcı olabilir.

5. Mobil Uyumluluk ve Uzaktan Geliştirme

Bu makalenin ana odağı VS Code içinde yerel kullanım olsa da, HTML çıktısı için mobil uyumluluk vurgusu yapılmıştır. Yazdığınız web tabanlı uygulamalar veya kod parçaları için mobil uyumluluğu düşünmek önemlidir. Continue'nun kendisi bir VS Code eklentisi olduğundan, VS Code'un mobil versiyonu veya uzaktan geliştirme özellikleri aracılığıyla erişilebilir. HTML ve CSS kod örneklerinizde, mobil cihazlarda iyi görünmesini sağlamak için aşağıdaki gibi temel medya sorgularını kullanabilirsiniz:

/* Temel mobil uyumluluk için medya sorgusu örneği */
@media (max-width: 768px) {
    .container {
        padding: 10px;
    }
    .sidebar {
        display: none; /* Mobil'de kenar çubuğunu gizle */
    }
    .main-content {
        width: 100%;
    }
}
    

Bu ileri düzey ipuçları, Continue eklentisini ve yerel AI modellerini kullanırken daha verimli olmanıza, performansı optimize etmenize ve AI'dan en iyi şekilde yararlanmanıza yardımcı olacaktır.

Sonuç ve Sıkça Sorulan Sorular

Bu makale boyunca, yerel yapay zeka modellerinin gücünü VS Code ortamınıza Continue eklentisi aracılığıyla nasıl entegre edeceğinizi adım adım keşfettik. Başlangıçta VS Code ve Continue kurulumundan, Ollama ile yerel modelleri indirme ve yapılandırmaya kadar temel adımları ele aldık. Özellikle, farklı görevler için en uygun AI modelini seçme esnekliği sunan çoklu model desteğinin önemini ve kullanımını detaylandırdık. Kod refactoring'den yeni özellik geliştirmeye ve hata ayıklamaya kadar gerçek dünya senaryolarıyla Continue'nun geliştirme süreçlerinizi nasıl hızlandırabileceğini somut örneklerle gösterdik. Son olarak, prompt mühendisliği, performans optimizasyonu ve ileri düzey kullanım ipuçlarıyla AI deneyiminizi daha da zenginleştirmenin yollarını öğrendik.

Yerel AI kullanımı, özellikle gizlilik, maliyet etkinliği ve çevrimdışı çalışma gereksinimleri olan geliştiriciler ve ekipler için vazgeçilmez bir çözüm sunmaktadır. Continue eklentisi, bu güçlü potansiyeli VS Code'un tanıdık ortamına getirerek, modern yazılım geliştirmenin geleceğinde önemli bir yer edinmektedir. Kendi AI asistanınızı kurmak ve geliştirme süreçlerinizi optimize etmek için artık tüm araçlara ve bilgiye sahipsiniz.

Sıkça Sorulan Sorular

1. Continue eklentisi sadece yerel AI modelleriyle mi çalışır?

Hayır, Continue eklentisi hem yerel AI modelleri (Ollama, LM Studio gibi) hem de bulut tabanlı AI hizmetleriyle (OpenAI, Anthropic, Google Gemini vb.) çalışabilir. Yapılandırma dosyasında (config.json) hangi sağlayıcıyı kullanacağınızı belirtebilirsiniz.

2. Yerel bir AI modelini çalıştırmak için ne tür donanıma ihtiyacım var?

En iyi performans için modern bir CPU ve özellikle büyük modellerle çalışacaksanız yeterli miktarda RAM (16GB veya daha fazlası) önerilir. NVIDIA GPU'nuz varsa (8GB VRAM veya daha fazlası), modellerin çok daha hızlı çalışmasını sağlayabilirsiniz. Apple Silicon çipler de iyi performans sunar.

3. Continue ile birden fazla modeli aynı anda kullanabilir miyim?

Evet, config.json dosyasında birden fazla modeli tanımlayabilir ve Continue arayüzündeki açılır menüden istediğiniz zaman bu modeller arasında geçiş yapabilirsiniz. Ancak, aynı anda birden fazla modelin aktif olarak yanıt üretmesi yerine, genellikle bir model seçilir ve onunla etkileşim kurulur.

4. Kendi ince ayarlı (fine-tuned) modelimi Continue ile kullanabilir miyim?

Evet, eğer kendi ince ayarlı modelinizi Ollama gibi bir yerel AI sunucusunda çalıştırabiliyorsanız, Continue bu modeli tıpkı diğer modeller gibi config.json dosyasında tanımlayarak kullanabilir. Kendi modelinizi eğitmek ve Ollama'da çalıştırmak, daha gelişmiş bir konudur ve Ollama'nın model import özelliklerini veya Hugging Face gibi platformları araştırmanız gerekebilir.

5. Continue eklentisi ücretli mi?

Hayır, Continue eklentisi açık kaynaklı ve ücretsizdir. Ancak, eğer bulut tabanlı AI hizmetlerini (OpenAI gibi) kullanırsanız, bu hizmetlerin kendi API kullanım ücretleri olabilir. Yerel AI modellerini kullanırken ise ek bir ücret ödemezsiniz (donanım maliyetleri hariç).