Memo Kılavuzu

Bir gece, ekranın başında, bir şeyi düşününce başlar bu iş genelde. Belki bir fikir vardır kafanda, belki bir sorun, belki sadece konuşacak biri lazımdır — ama seni bir sunucuya, bir şirkete, birinin eğitim verisine dönüştürmeden dinleyecek biri. Memo tam olarak bu ihtiyaçtan doğdu: kendi bilgisayarında çalışan, seni gerçekten hatırlayan, ve hiçbir yere hiçbir şey göndermeyen bir yapay zeka.

Bunu söylemek kolay, ama üzerine biraz düşünmek gerekiyor. Piyasadaki çoğu asistan bulutta yaşar — mesajını yazarsın, bir sunucuya gider, orada işlenir, cevap geri gelir. Aradaki her adımda verin senin elinden çıkar. Memo'da bu adım yok. Backend'i (Go ile yazılmış, sessiz, arka planda çalışan bir süreç) kendi makinende çalışır, arayüzü (Flutter ile yazılmış masaüstü uygulaması) yine kendi makinende çalışır, ve ikisi birbiriyle sadece localhost üzerinden, dışarı hiç çıkmadan konuşur. İstersen bir bulut sağlayıcısına (OpenAI, Claude, Gemini, ne olursa) bağlanabilirsin — ama bu senin seçimin, Memo'nun varsayılanı değil. Varsayılan olan, hiçbir yere bağlanmamak.

Bunun arkasında bir şirket, bir yatırımcı, bir büyüme hedefi yok. Memo'yu 16 yaşında bir yazılımcı olan Buğra Akdemir tek başına geliştiriyor — ticari bir amaç gütmeden, gizliliğine önem verenler için açık kaynak olarak. Bunu bilmek önemli, çünkü kılavuzun ilerleyen bölümlerinde göreceğin tuhaflıkların, cilalanmamış köşelerin, "şu an böyle ama düzeltiliyor" notlarının sebebi de bu: elinde büyük bir mühendislik ekibi olmayan biri, gerçek kullanıcılardan gelen geri bildirimle bir ürünü büyütüyor. Sürüm notlarını okuduğunda bunu hemen fark edersin — her sürüm, önceki sürümde biri tarafından yaşanmış gerçek bir sorunun düzeltilmesiyle dolu.

Memo'yu tanımlamanın en doğru yolu belki de şu: bir "ikinci beyin". Değirmenin taşı gibi, arkanda sessizce dönen, söylediğin her şeyi bir kenara not eden, sen istemesen de bağlam kurmaya çalışan bir katman. Sohbet ettiğin an bir kayıt cihazı gibi davranmaz — konuştuğun şeyleri anlamaya, aralarında bağ kurmaya, ileride lazım olacağını sezdiği şeyleri saklamaya çalışır. Bu kılavuzun geri kalanı, bu fikrin pratikte ne anlama geldiğini, hangi dişlilerin birbirine nasıl bağlandığını, ve bir şeyler ters gittiğinde nereye bakman gerektiğini anlatıyor.

01Kapıdan İçeri: Kurulumun İlk Beş Dakikası

Bir yazılımı kurmak genelde can sıkıcıdır — bağımlılıklar, terminal komutları, "şu paketi de kurman lazım" uyarıları. Memo bu konuda bilinçli bir tercih yapmış: llama.cpp (yerel modelleri çalıştıran motor), sqlite-vec (vektör arama motoru), whisper.cpp (sesi metne çeviren motor) — hepsi kurulum dosyasının içinde gelir. Docker yok, manuel derleme yok, "önce şunu kur" listesi yok. Windows için bir .exe, Linux için .AppImage/.deb/.tar.gz, macOS için evrensel bir .zip, Android için bir .apk indirirsin, çalıştırırsın, biter. macOS ve Linux'ta terminale alışıksan tek satırlık bir kurulum betiği de var; onu tekrar çalıştırmak güvenlidir, verilerine dokunmadan sadece programın kendisini tazeler.

Kurulumdan sonra karşına çıkan ilk şey bir sihirbaz. Adını sorar, asistanına bir isim vermeni ister ("Memo" kalabilir, ya da tamamen farklı bir şey olabilir — bazı kullanıcılar kendi asistanlarını "Athena" ya da "Dave" diye çağırıyor), ve bir kişilik seçmeni ister: gündelik, resmi, teknik, yaratıcı, eğlenceli, arkadaş canlısı ya da tamamen kendi yazdığın bir sistem promptu. Bu seçim kalıcı değil — istediğin an Ayarlar → Sistem Prompt'tan değiştirebilirsin — ama ilk izlenimi belirlediği için üzerine biraz düşünmeye değer.

İşin can alıcı kısmı burada başlıyor: donanımına göre model önerisi. Memo, RAM'ini ve varsa GPU'nu okuyup sana uygun bir sohbet modeli + hafıza (embedding) modeli çifti öneriyor, ve tek bir butonla ikisini birden indirmeye başlatıyor — kurulumun geri kalanına devam ederken arka planda inmeye devam ediyorlar. Burada karşına çıkacak temel ayrım şu: yerel bir model mi çalıştıracaksın, yoksa dışarıdaki bir sağlayıcıya (OpenAI, Claude, Gemini gibi) mı bağlanacaksın?

Yerel model çalıştırmanın cazibesi açık — hiçbir şey bilgisayarından çıkmaz, internet olmasa da çalışır, API faturası gelmez. Bedeli de açık: donanımın modelin büyüklüğünü belirler. Zayıf bir bilgisayarda küçük, hızlı ama sınırlı bir model çalıştırırsın; güçlü bir GPU'n varsa çok daha yetenekli bir modeli aynı hızda çalıştırabilirsin. Dış bir sağlayıcıya bağlanmak ise donanım sınırını tamamen ortadan kaldırır — GPT-4o veya Claude gibi devasa modellere, kendi makinende hiç yer kaplamadan erişirsin — ama bunun karşılığında iki şey ödersin: mesajların o sağlayıcının sunucusuna gider (Memo şifreler, saklar, günlüğe yazmaz, ama gönderdiği andan itibaren o sağlayıcının kendi gizlilik politikası devreye girer), ve kullandıkça para öder hâle gelirsin. Memo'nun felsefesi burada seni bir tarafa zorlamıyor: ikisini birden kurabilir, günlük sohbeti yerel modelle yapıp zor bir problem geldiğinde bulut modeline geçebilirsin. Karar senin, model başına, konuşma başına.

Model indirmeyi kurulum sırasında atlayabilirsin de — sonradan Model Mağazası'ndan istediğin an geri dönebilirsin, ya da hiç yerel model kurmadan sadece bir bulut sağlayıcısının API anahtarını girip devam edebilirsin. Kurulumun en yaygın takıldığı nokta genelde şu oluyor: kullanıcı bir model indirmeye başlıyor, sabırsızlanıp uygulamayı kapatıyor, sonra "model çalışmıyor" diye şikayet ediyor — oysa indirme yarım kalmıştır. Model Mağazası'na dönüp indirmenin tamamlanıp tamamlanmadığını kontrol etmek genelde ilk yapılması gereken şey.

02Sıradan Bir Sohbetin Altında Dönen Çark

İlk mesajını yazdığında gördüğün şey sıradan bir sohbet kutusu — ama görünmeyen kısımda epey iş dönüyor. Her mesajın (hem senin yazdığın, hem Memo'nun cevabı) parçalara ayrılıyor, sayısal bir vektöre dönüştürülüyor (buna "embedding" deniyor) ve bir SQLite veritabanında saklanıyor. Bu, Memo'nun "hafızası" — ve klasik bir sohbet geçmişinden temelde farklı çalışıyor. Sıradan bir chatbot'ta geçmiş, sadece o pencereye sığdığı kadar hatırlanır; pencere dolunca en eski mesajlar sessizce düşer. Memo'da böyle bir sınır yok — aylar önce söylediğin bir şey, konuyla alakalıysa, bugünkü sohbete geri çağrılabilir.

Bunun nasıl çalıştığını anlamak, Memo'yla olan ilişkini gerçekten değiştiriyor. Her yeni mesaj geldiğinde Memo, arşivinde o mesajla anlamca en yakın olan anıları arıyor — sadece aynı kelimeleri değil, aynı anlamı taşıyan cümleleri de buluyor. Bu arama tek bir yöntemle değil, ikisinin birleşimiyle yapılıyor: biri anlam tabanlı (vektör benzerliği), diğeri kelime tabanlı (tam metin arama, FTS5). İkisinin sonuçları "Reciprocal Rank Fusion" denen bir yöntemle harmanlanıyor — teknik ismi korkutucu ama fikri basit: iki farklı arama yönteminin ikisi de bir şeyi öne çıkarıyorsa, o şey muhtemelen gerçekten önemlidir. Bu hibrit yaklaşım aslında görece yeni — uzun süre sistemin kelime tabanlı yarısı sessizce hiç çalışmıyordu, hiçbir hata vermeden; bu artık düzeltildi ve iki yöntem de gerçekten birlikte çalışıyor.

Bunun üstüne bir katman daha var: sabitlenmiş gerçekler. Adın, doğum günün, evcil hayvanının adı gibi çekirdek bilgiler ayrı bir listede tutuluyor ve hiçbir aramaya, hiçbir benzerlik skoruna bağlı kalmadan her prompt'a otomatik ekleniyor. Bunun sebebi basit: "favori renginiz nedir" gibi kısa ve kesin bir gerçek, hafıza deposu büyüdükçe arama sonuçlarında kaybolabiliyor — sabitlenmiş gerçekler katmanı buna karşı bir güvence sağlıyor. /remember komutuyla bir şeyi elle bu listeye ekleyebilirsin, ama artık buna hiç gerek kalmadan da oluyor — sıradan bir cümle içinde geçen kişisel bir bilgi (köpeğinin adı, mesleğin, doğum günün) arka planda sessizce fark edilip aynı listeye ekleniyor. Bunu yapan kod bir süre boyunca (tek bir karakterlik bir veritabanı hatası yüzünden) hiçbir şeyi gerçekten kaydetmiyordu — /remember yazıp "kaydedildi" mesajını görsen bile arkada hiçbir şey işlenmiyordu. Bu, çok uzun süredir orada duran, hiç fark edilmeyen türden bir hataydı; artık düzeltildi.

Peki Memo bazen sana hiç söylemediğin bir şeyi nasıl "hatırlıyormuş" gibi davranıyor? Cevap yukarıdaki mekanizmada gizli: sen bir şeyi açıkça "hatırla" demeden söylediğinde bile, Memo bunu arka planda geçen bir cümle olarak kaydedebiliyor. Bu bazen hoş bir sürpriz oluyor ("ay, doğum günümü nereden biliyor" — çünkü geçen ay bir cümle içinde geçmiştin), bazen de rahatsız edici — özellikle geçici, önemsiz bir detayın kalıcı bir "gerçek" muamelesi görmesi. Böyle bir durumda yapman gereken, o anıyı hafıza yönetimi ekranından bulup silmek; sistem her şeyi sonsuza kadar saklamaya çalışmıyor, ama bir kez "önemli" diye işaretlenmiş bir şeyi kendiliğinden unutmuyor da.

Peki tam tersi olduğunda, yani Memo bariz bir şeyi unutmuş gibi göründüğünde? Bunun birkaç yaygın sebebi var. Birincisi, çok-konulu sorular — "adımı, doğum günümü ve favori rengimi biliyor musun" gibi tek cümlede üç farklı şey sorduğunda, eskiden bu sorgu tek bir harmanlanmış aramaya sıkışıyor ve üçte ikisini dönebiliyordu; artık her konu kendi başına aranıyor, ama eğer hâlâ eksik cevap alıyorsan güncel sürümde olup olmadığını kontrol etmekte fayda var. İkincisi, neredeyse-yinelenen bir kalabalık — aynı bilgiyi biraz farklı kelimelerle birkaç kere söylemişsen, bu kayıtlar arka planda periyodik olarak birleştiriliyor; bu birleştirme sürecinde eski, zaten birleştirilmiş bir kayıt bazen güncel karşılığından önce çıkıp yanlış (eski) bir cevaba yol açabiliyordu — bu da düzeltilmiş sorunlardan biri, ama benzer bir kafa karışıklığı yaşarsan hafıza ekranından o konudaki kayıtlara bakmak faydalı. Üçüncüsü, ve en temel olanı: embedding modelinin çalışmıyor olması. Hafıza aramasının çalışması için arka planda bir embedding sunucusunun ayakta olması gerekiyor — eğer bu süreç bir sebepten (önceki bir çökme, portu tutan öksüz bir süreç) başlamamışsa, motor durum çubuğu bazen yanıltıcı bir şekilde "çalışıyor" göstermeye devam edebiliyordu, oysa arkada hiçbir gerçek bağlantı yoktu. Bunun için Memo artık açılışta zaten çalışan bir embedding sunucusu olup olmadığını kontrol edip ona düzgünce yeniden bağlanıyor; yine de motor durum çubuğuna bir göz atmak, hafıza cevap vermiyor gibi hissettiğinde ilk bakılacak yer olmalı.

Gizli mod açıkken bu bahsettiğimiz hiçbir şey olmuyor — o bölüme birazdan geleceğiz, ama şunu şimdiden söylemek lazım: sıradan sohbetteki bu "hatırlama" hissi, gizli moddayken tamamen kayboluyor, çünkü kaybolması gereken de tam olarak bu.

03Ajan Modu: Sohbetten Fazlası

Bir noktada, sadece konuşmak yetmiyor. "Şu dosyayı bana özetle", "bu klasördeki dosyaları listele", "şu komutu çalıştır da sonucunu gör" dediğin an, aslında bir sohbet ortağından değil, bilgisayarınla etkileşime girebilen bir asistandan bahsediyorsun demektir. İşte bu, Ajan Modu'nun devreye girdiği yer.

Ajan Modu açıldığında Memo'ya sekiz yerleşik araç açılıyor: dosya okuma, dosya yazma, dosya silme, dizin listeleme, komut çalıştırma, dosya arama (glob desenleriyle), dosya bilgisi alma, ve ortam değişkenlerini listeleme (hassas olanları maskeleyerek). Bunların her biri farklı bir tehlike seviyesinde sınıflandırılmış — dosya okumak ya da dizin listelemek "güvenli" sayılıp otomatik izinle çalışırken, dosya silmek ya da bir terminal komutu çalıştırmak "tehlikeli" kategorisinde, yani senin açık onayını gerektiriyor. Bu ayrım gelişigüzel değil — arkasında bir izin sistemi var, ve bu sistem altı farklı politikadan oluşuyor: her seferinde sor, bir kere izin ver, oturum boyunca izin ver, kalıcı izin ver, bir kere reddet, kalıcı reddet. Kalıcı kararlar diske yazılıyor, oturum kararları sadece o oturum boyunca RAM'de yaşıyor.

Bunun altında bir de sandbox var — ajan, çalışma dizininin dışına çıkamıyor, komutlar bir zaman aşımıyla sınırlı, ve bir kara liste (23 farklı desen) rm -rf / gibi yıkıcı komutları, disk formatlamayı, yetki yükseltmeyi (sudo, su), fork bomb'ları ve reverse shell denemelerini daha çalışmadan engelliyor. Bu kara listedeki bir boşluk — desen eşleştirmesindeki küçük bir açık — bazı yıkıcı komutların bu kontrolü atlatabilmesine yol açabiliyordu; bu kapatıldı, ama şunu bilmek önemli: bu ek bir güvenlik ağı, asıl güvenlik senin onayın. Bununla bağlantılı bir başka boşluk daha bulunup kapatıldı: proje içinde henüz var olmayan bir hedefe işaret eden bir symlink, bir dosya-düzenleme aracının sandbox'lanmış proje dizini dışına yazmasına izin verebiliyordu — klasik bir "sandbox kaçışı" türü, yakalanıp yamalanan bir örnek. Bu tür düzeltmeler Memo'nun geliştirilme tarzını iyi özetliyor: gerçek kullanım sırasında bulunan gerçek boşluklar, hızla kapatılıyor.

Ajan Modu'nun düz sohbete kıyasla gerçekten iyi olduğu yer, "yap" fiiliyle başlayan isteklerdir — "şu dosyayı düzenle", "bu projenin yapısını çıkar", "şu komutu çalıştırıp sonucu yorumla". Sıradan sohbet sana sadece metin döner; ajan modu, o metnin arkasındaki eylemi gerçekleştirir. Bunu bir de Claude Code'a benzetmek mümkün — ve zaten Memo'nun kendi tasarımı da bilinçli olarak o modele bakıyor. Fark şu: Memo'nunki, hangi sağlayıcıyı kullanırsan kullan aynı izin diyaloğu ve aynı sandbox üzerinden çalışıyor.

Yaygın kafa karışıklığı noktalarından biri, ajan modunun nerede açılacağı. Uzun süre ajan modunu açmak, sıradan Chat ekranından ayrılıp bambaşka bir Ajan sekmesine geçmek anlamına geliyordu — sıradan bir sohbetten oraya geçişin hiçbir kısayolu yoktu. Artık Chat ekranının üst çubuğunda, mevcut web arama anahtarının hemen yanında bir ajan modu anahtarı var; sohbeti hiç terk etmeden açıp kapatabiliyorsun. İkinci yaygın nokta, izin istemleriyle ilgili: bir aracı çalıştırmak isteyip de hiçbir onay penceresi görmeyince kullanıcılar "ajan modu çalışmıyor" sanıyor — oysa çoğu zaman sorun, izin diyaloğunun arka planda kaybolmasıydı; backend'e ulaşılamadığında ya da sohbet değiştirildiğinde diyalog bazen sessizce kayboluyor, ajan da askıda kalıyordu. Bu artık düzeltildi: bağlantı sorunu olduğunda diyalog açık kalıp neyin ters gittiğini gösteriyor, artık var olmayan bir istek için sonsuza dek beklemiyor. Üçüncü nokta da otomatik-izin modu (Shift+Tab ile açılan) — bir zamanlama sorunu yüzünden bu anahtar arayüzde açık görünse bile ajan her araç çağrısında yine de izin sormaya devam edebiliyordu; bu da artık gerçekten çalışıyor.

Son olarak: ajan modu, yalnızca dış bir sağlayıcı (OpenAI, Claude, Gemini, Grok, Groq, OpenRouter, Ollama, OpenCode Zen/Go) etkinken çalışıyor — yerel llama.cpp motoru henüz araç çağırma desteği sunmuyor. Yani ajan modunu denemek istiyorsan, önce bir dış sağlayıcı bağlaman gerekiyor; bir sonraki bölüm tam olarak bunu anlatıyor.

04Orkestra Modu: Bir Ekip Kurmak

Bazı işler tek bir kafayla değil, bir ekiple daha iyi yürür. Orkestra Modu, tam olarak bu fikri modeller üzerinde uyguluyor: bir "Şef" model senin isteğini alt görevlere ayırıyor, her görevi uzmanlaşmış bir "role" atıyor, ve o roller kendi modelleriyle (isteğe göre paralel ya da sırayla) çalışıp sonuçlarını üretiyor; en sonda yine Şef, tüm bu parça parça çıktıları tek, tutarlı bir cevapta birleştiriyor.

Sekiz yerleşik rol var: planlayıcı (mimari ve görev dağılımı), ön yüz (React/Flutter tarzı UI işleri), arka yüz (API, veritabanı), hata avcısı, incelemeci, güvenlik, DevOps, ve genel amaçlı bir yedek. Her rolün varsayılan olarak farklı bir model ataması var — mesela planlayıcıya Claude, ön yüze Grok, arka yüze GPT-4o, hata avcısına Gemini atanmış olabilir; bunların hepsini istediğin gibi değiştirebilir, hatta tamamen özel roller (kendi ismin, kendi model atamanla, kendi sistem promptunla) tanımlayabilirsin. Fikir şu: her modelin bir güçlü yanı var — biri akıl yürütmede, biri hızda, biri kod üretiminde daha iyi — ve orkestra bunları görev bazında birleştiriyor.

Peki bu ekstra gecikme ve maliyete ne zaman değer? Cevap net: karmaşık, çok parçalı işlerde. "React dashboard'u + Go backend'i yaz" gibi bir istek, tek bir modelin tek seferde iyi yapması zor bir iştir — orkestra bunu ayrı ayrı uzmanlıklara böldüğü için genelde daha derli toplu bir sonuç veriyor. Ama günlük, tek parçalı bir soru için ("bugün hava nasıl olur", "şu fonksiyonu bana açıkla") orkestra sadece gereksiz gecikme ve gereksiz API çağrısı maliyeti ekler — Şef önce plan çıkarmak için bir çağrı yapıyor, sonra her görev kendi çağrısını yapıyor, sonra Şef sentezlemek için bir çağrı daha yapıyor. Yani orkestra, "büyük ve çok parçalı" işler için bir araç; sıradan sohbetin varsayılan modu olması gerekmiyor.

Bunun pratik bir sonucu var: orkestra da tıpkı ajan modu gibi bir dış sağlayıcı gerektiriyor (rollerin bağlı olduğu modeller genelde dış API'lerden geliyor), ve şu an sağlayıcı yönlendiricisinin (router) yedek zincirini bypass ediyor — yani bir rolün bağlı olduğu sağlayıcı başarısız olursa, ajan modundaki gibi otomatik bir sonraki sağlayıcıya düşme mekanizması yok, doğrudan hata dönüyor. Bunu bilmek, orkestra kullanırken "neden bu görev başarısız oldu" sorusuna daha hızlı cevap bulmanı sağlar — muhtemelen o role atanmış sağlayıcı o an ulaşılamaz durumda.

05Harici Sağlayıcılar: Kendi Model Seçimini Yapmak

Memo'nun kendi yerel motoru dışında dokuz bulut sağlayıcısına bağlanabiliyorsun: OpenAI, Anthropic Claude, Google Gemini, xAI Grok, Groq (ultra hızlı çıkarım donanımıyla tanınıyor), OpenRouter (tek bir API üzerinden 300'den fazla modele erişim), Ollama (kendi makinende ya da ağındaki başka bir yerel model sunucusu), ve en yeni ikili — OpenCode Zen ve OpenCode Go. Bu son ikisinde, tıpkı OpenRouter'da olduğu gibi, model adını elle yazman gerekmiyor: sağlayıcı ekranındaki "Seç" butonuna basıyorsun, API'nin o an gerçekten sunduğu canlı model listesinden birini seçiyorsun. Zen kullandıkça öde mantığıyla çalışıyor (bazı modelleri ücretsiz), Go ise abonelik tabanlı.

Her sağlayıcı kendi API anahtarıyla, kendi model seçimiyle, kendi bağlam penceresi ayarıyla bağımsız olarak yapılandırılıyor. Bu anahtarlar diskte düz metin olarak durmuyor — makineye özgü bir anahtardan türetilen AES-256-GCM şifrelemesiyle saklanıyor. Bunun bir bedeli var: bu şifreleme makineye bağlı olduğu için providers.json dosyasını olduğu gibi başka bir bilgisayara kopyalayıp yapıştırmak işe yaramaz — o dosyayı çözecek anahtar (machine.key) ayrıca gerekiyor. Uzun süre bu anahtar dosyası, tam yedekleme özelliğinin (.memo dışa aktarımı) dışında kalıyordu; yani bir yedeği başka bir makinede geri yüklediğinde, tüm API anahtarların sessizce, kalıcı olarak çözülemez hale geliyordu. Bu artık düzeltildi ve machine.key yedeğin bir parçası — ama eski bir yedeğin varsa ve API anahtarların bir türlü çalışmıyorsa, bunun sebebinin tam olarak bu olabileceğini bilmekte fayda var; en temiz çözüm, anahtarları elle yeniden girmek.

Bağladığın sağlayıcılar, ekleme sırana göre bir yedek zinciri oluşturuyor. Birincisi başarısız olursa (hız sınırına takılırsa, kimlik doğrulaması reddederse, zaman aşımına uğrarsa) Memo otomatik olarak bir sonrakine geçiyor. Bir sağlayıcı üst üste üç kez başarısız olursa otomatik olarak devre dışı bırakılıyor; arka planda çalışan bir sağlık kontrolü, beş dakikada bir bu devre dışı sağlayıcıları test edip toparlandıklarında kendiliğinden geri açıyor. Bu, hiçbir müdahale gerektirmeden çalışan sessiz bir güvenlik ağı — ama bazen kafa karıştırıcı da olabiliyor: bir sağlayıcı geçici bir sorun yaşadı diye üç hata sonrası tamamen devre dışı kalabiliyor, ve sen "neden artık bu modeli kullanmıyor" diye sorduğunda cevap, ayarlar ekranındaki o sağlayıcının kartına bakmak.

En yaygın kurulum hatası, muhtemelen tahmin edeceğin gibi, yanlış ya da eksik yapıştırılmış bir API anahtarı — ama ikinci en yaygını daha sinsi: bağlam penceresi ayarı. Bağlam bütçesi (her istekte modele gönderilen sohbet geçmişinin miktarı) sağlayıcı türüne değil, seçtiğin modele bağlı — bu alanı boş bırakırsan makul varsayılanlar kullanılıyor (Gemini için 1 milyon token, Claude için 200 bin, diğerleri için 128 bin), ama gerçek modelin penceresinden çok daha büyük bir sayı girersen istekler tuhaf şekillerde başarısız olabiliyor. Ayrıca geçmişte, Claude aktif sağlayıcıyken model alanı boş bırakılan mesajların, yapılandırılmış modele düşmesi gereken bir yedek mekanizma hiç çalıştırılmadığı için boş bir model alanıyla gönderilebildiği bir hata vardı — bu düzeltildi ve artık bir regresyon testiyle korunuyor.

06Yerel Modeller, llama.cpp ve Model Mağazası

Bir yerel model çalıştırmak istediğinde, arkada dönen motor llama.cpp — açık kaynak, hızlı, ve Memo'nun paketinin içinde zaten gömülü gelen bir çıkarım motoru. Bunu ayrıca kurman gerekmiyor; ilk çalıştırmada Memo, platformuna uygun llama-server ikili dosyasının olup olmadığını kontrol ediyor, eksikse otomatik indiriyor, ve GPU'nu tarıyor — NVIDIA için CUDA, AMD için ROCm/Vulkan, Apple için Metal.

Model bulma ve indirme işi Model Mağazası'nda (yan menü, bazen "Fabrika" olarak da anılır) toplanıyor, iki panelli bir düzende: solda zaten yüklediğin modeller, sağda HuggingFace'in GGUF kataloğundan aranabilir bir liste. Bir modele bakarken karşına çıkan donanım uygunluk rozeti ("✓ Uyar", "~ CPU uygun", "× Çok büyük") tahmin değil — Memo senin RAM'ini ve VRAM'ini gerçekten ölçüp modelin boyutuyla karşılaştırıyor. Niceleme etiketleri de (Q4_K_M, Q8_0 gibi kriptik GGUF isimleri) sade dile çevriliyor — "harika kalite, hızlı" ya da "maksimum kalite" gibi; çoğu model için Q4_K_M iyi bir başlangıç noktası, kalite ile hız arasında dengeli bir orta yol.

Discover sekmesinde araç-çağırma, görsel, kod ve embedding yeteneklerine göre filtreleme yapabiliyorsun. Bu filtreler eskiden birbirini dışlayan bir mantıkla (AND) birleşiyordu — iki filtre seçmek genelde hiçbir sonuç döndürmüyordu; artık OR mantığıyla birleşiyor ve düzgün, çoklu-seçim dropdown'lara gruplandı, "N filtre aktif · temizle" göstergesiyle. Araç çağırma ve kod yeteneği rozetleri de artık modelin gerçek chat template'ine ve etiketlerine bakılarak belirleniyor, "bilinen modeller" listesine göre değil — bu özellikle yeni çıkan ya da az bilinen modeller için daha doğru sonuç veriyor.

Kısıtlı erişimli modeller (bazı Google Gemma sürümleri gibi) HuggingFace tarafında bir erişim onayı istiyor — bu tür bir model indirme denemesi 401 hatasıyla başarısız olabiliyor, ve eskiden bu durumda indir butonu kalıcı olarak "İptal" yazısında takılı kalıyordu (bu artık düzeltildi). Gerçekten kısıtlı bir modele erişmek istiyorsan bir HuggingFace token'ı gerekiyor; onun yerine, kısıtlı olmadığı doğrulanmış eşdeğer modeller önerilen listeye zaten eklenmiş durumda, dolayısıyla çoğu kullanıcının bu adıma hiç girmesi gerekmiyor.

Bir zamanlar ikinci bir indirmeyi başlatmak doğrudan reddediliyordu — artık birden fazla indirme aynı anda çalışabiliyor, birleşik ilerlemesi motor durum çubuğunda gösteriliyor. Bağlam boyutu ayarı da eskiden serbest bir metin alanıydı; gerçekçi olmayan bir sayı girmek model sunucusunu çökertebiliyordu. Artık Memo modelin gerçek maksimum bağlamını dosyanın kendisinden okuyup kaydırıcının bunu aşmasına izin vermiyor — yani artık kendi kendine model motorunu çökertmen mümkün değil.

07Terminal CLI: Klavyeden Ayrılmayanlar İçin

Bir masaüstü uygulamasının yanında bir de terminal istemcisi bulunması ilk bakışta fazlalık gibi görünebilir — ama terminalde yaşayan biri için (geliştiriciler, script yazanlar, pencere değiştirmekten hoşlanmayanlar) bu, gerçek bir kısayol. Memo'nun terminal CLI'ı, masaüstü uygulamasının konuştuğu aynı REST API'ye aynı şekilde konuşuyor — yani ikisi de aynı backend'i, aynı hafızayı, aynı sağlayıcı yapılandırmasını paylaşıyor.

CLI'ın en can alıcı özelliği slash komutları: /model ile aktif modeli değiştirebiliyorsun, /session ile geçmiş sohbetler arasında (artık sadece CLI'dan başlatılanlar değil, masaüstünde başlatılmış olanlar da dahil) gezinebiliyorsun, /orchestra orkestra ayarlarını açıyor, /insight Memo'nun kendi gözlemlerini soruyor, /remember bir gerçeği elle kaydediyor. Mesaj kutusunda @ yazıp bir dosya adı bahsi yaptığında otomatik tamamlama devreye giriyor — kod tabanı üzerinde çalışırken belirli bir dosyayı işaret etmek için kullanışlı.

Karşılama paneli iki sütuna bölünmüş, bronz tonlu bir palet ile yeniden tasarlandı — bir tarafta maskot ve model/yol bilgisi, diğer tarafta dönen bir ipucu ve güncelleme bildirimi; terminali nasıl yeniden boyutlandırırsan boyutlandır artık bozulmuyor. CLI tamamen yerelleştirilmiş durumda (Türkçe/İngilizce) ve masaüstü uygulamasıyla aynı dil ayarını takip ediyor.

Etkileşimli sohbeti hiç açmadan çalıştırabileceğin bağımsız bayraklar da var: --kill (arka planda çalışan Memo'yu tamamen kapatır), --help, --version, --status, --gui (masaüstü uygulamasını açar), --github, --bugreport, --docs. Bunlar özellikle bir script içinden ya da bir process yöneticisinden Memo'yu yönetmek istediğinde işine yarıyor.

CLI ile masaüstü uygulaması arasındaki ilişki bir süre kırılgandı: CLI kendi backend'ini başlattıysa ve sen /gui ile masaüstü uygulamasını açtıysan, CLI'ı kapatmak backend'i — ve hâlâ açık olan masaüstü uygulamasını — sessizce beraberinde götürüyordu. Artık backend kendi bağımsız süreci olarak çalışıyor; CLI ya da masaüstü uygulamasından herhangi biri onu kullandığı sürece ayakta kalıyor, birini kapatmak diğerini bozmuyor, ve ikisi de kapandığında backend bir-iki dakika içinde kendiliğinden sönüyor — arka planda boşuna bellek tüketmemesi için. Bir diğer köklü sorun, model indirmenin CLI içinden yapılmasıydı: ilerleme çubuğu sadece bir zamanlayıcıdan okuyordu, klavyeden hiç okumuyordu, iptal etmenin hiçbir yolu yoktu, ve yavaş bir bağlantı tüm terminali dondurabiliyordu. Model indirme artık tamamen masaüstü uygulamasına taşındı — CLI'daki /model-download artık sadece senin için GUI'yi açıyor, gerçek işi orada, gerçek ve iptal edilebilir bir ilerleme çubuğuyla yapıyorsun.

Kalıcı bir soru: CLI backend'i mi paylaşıyor, yoksa ayrı mı çalışıyor? Cevap: aynı backend'i paylaşıyor. Bu yüzden CLI'dan başlattığın bir sohbeti masaüstünde devam ettirebiliyorsun (ve tam tersi) — /session komutu artık ikisini de gösteriyor. Bu paylaşım aynı zamanda şu demek: CLI'da yaptığın bir ayar değişikliği (sağlayıcı, model, ajan izinleri) masaüstünde de anında yansıyor, çünkü aslında aynı veriye bakıyorlar.

08WhatsApp: Bir Köprü, Bir Sınır

WhatsApp entegrasyonu ilk duyulduğunda insanı biraz tedirgin edebilir — "yapay zeka mesajlarıma mı bakacak?" Cevap evet, ama sınırları net: Memo, WhatsApp hesabına whatsmeow kütüphanesi üzerinden, resmi WhatsApp Business API'sine hiç dokunmadan, çoklu cihaz web protokolü ile bağlanıyor. Telefonundaki WhatsApp'ta "Bağlı Cihazlar" menüsünden bir QR kod okutuyorsun, ve bağlantı kuruluyor — telefon numarası kaydı yok, üçüncü taraf bir API'ye ücret ödemek yok.

Bağlandıktan sonra Memo'nun arayüzünden mesajları okuyabiliyor, yanıtlayabiliyor, tüm sohbetlerinde tam metin arama yapabiliyorsun. Yapay zeka burada iki şekilde devreye giriyor: birincisi, senin isteğinle bir yanıt taslağı hazırlaması ya da uzun bir konuşmayı özetlemesi ("Berra'yla ne konuşmuştuk"); ikincisi, ajan modu açıksa, kendisine açılan whatsapp_send, whatsapp_search, whatsapp_latest, whatsapp_messages araçlarıyla senin adına mesaj gönderebilmesi (yine izin sistemi devrede — bu da bir "tehlikeli" işlem sayılıyor). "Berra'ya mesaj at" dediğinde isim çözümlemesi otomatik çalışıyor, kişi listende arayıp doğru numarayı buluyor.

Gizlilik çerçevesi burada da aynı ilkeye dayanıyor: tüm mesajlar yerel kalıyor, data/whatsapp/ altında WAL modlu bir SQLite'ta saklanıyor, hiçbir yere gönderilmiyor. WhatsApp mesajları aynı zamanda arka planda RAG hafızasına, proaktif öğrenme sistemine ve duygu (mood) motoruna da besleniyor — yani WhatsApp'ta birine "yarın 11'de halısaha" dediğinde, bu bilgi hem WhatsApp sohbetinde kalıyor hem de takvim sistemine sızıp otomatik bir hatırlatıcıya dönüşebiliyor. Bu bölümler birbirinden kopuk değil; Takvim ve Rutinler bölümünde bunu daha detaylı göreceğiz.

Bir süre boyunca, altyazılı gelen görseller, videolar ya da belgeler sessizce göz ardı ediliyordu — canlı mesajlardan sadece düz metin okunuyor, medyanın altyazısı tamamen yok sayılıyordu. Yani birisi sana bir fotoğraf gönderip altına "yarın saat 3'te" yazsa, Memo bu bilgiyi hiç görmüyordu. Bu artık düzeltildi. Bağlantı tarafında da bir güvenilirlik cilası var: QR bekleme ve bağlı kalma durumları arasında adaptif bir yoklama aralığı (QR beklerken 2 saniye, bağlıyken 15 saniye), kopmalarda üstel geri sarma ile otomatik yeniden bağlanma, ve geçmiş senkronizasyonunda çift kayıt oluşmasını engelleyen bir "sadece yoksa ekle" mantığı var — yani telefon uygulamasını kapatıp açtığında ya da bağlantı koptuğunda mesajların ikiye katlanmayacağından emin olabilirsin.

Yakın zamanda bulunup düzeltilen bir güvenlik açığı da burada yaşandı: WhatsApp'ın profil fotoğrafı sorgusu üzerinden erişilebilen, golang.org/x/text kütüphanesindeki bir sonsuz döngü açığı — bu, bağımlılık güncellemeleriyle kapatıldı. Bunu bilmenin pratik faydası yok, ama Memo'nun güvenlik yaklaşımını gösteriyor: govulncheck gibi otomatik taramalarla bulunan sorunlar, kaynağı ne kadar dolaylı olursa olsun (burada bir profil fotoğrafı sorgusu kadar masum bir şey) ciddiye alınıp yamanıyor.

09Takvim, Hatırlatıcılar ve Rutinler: Zamanı Yönetmek

İki özellik var burada, ve birbirlerinden ayrı düşünmek zor: biri senin söylediğin bir şeyi otomatik olarak fark edip takvime ekleyen sistem, diğeri senin bilinçli olarak kurduğun, tekrar eden otomasyonlar. İkisi de aynı temel fikre dayanıyor — Memo'nun senin adına zamanla ilgili bir şeyi hatırlaması — ama tetikleyicileri farklı.

Takvim tarafı, konuşmalarından (hem sıradan sohbette hem WhatsApp'ta) niyet çıkarımı yapan bir sistemle besleniyor. "Yarın 11'de halısaha oynayacağım" dediğinde, bu cümle önce hızlı bir anahtar kelime filtresinden geçiyor (zaman/niyet ifadeleri içermeyen mesajlar hiç modele gönderilmeden elenir — bu, her mesajı pahalı bir LLM çağrısına sokmamak için var), filtreyi geçen mesaj modele gönderiliyor ve model bunun bir takvim etkinliği mi yoksa bir alışkanlık beyanı mı olduğuna karar veriyor. Bir etkinlik tespit edilince onay sorulmadan doğrudan takvime ekleniyor — friction azaltmak bilinçli bir tercih, yanlışsa zaten silebiliyorsun. Hatırlatma süresi (10 dakika, 15 dakika, 30 dakika, 1 saat, 2 saat) senin seçtiğin bir pencere, ve o pencereye girildiğinde bir hatırlatma tetikleniyor.

Rutinler ise tam tersi yönden çalışıyor: sen düz dille ne istediğini ve ne sıklıkla olmasını istediğini anlatıyorsun ("her sabah 8'de günün özetini çıkar", "haftada bir Pazar akşamı harcamalarımı hatırlat"), Memo bunu arka planda zamanına göre çalışan bir otomasyona çeviriyor. Burada anlaşılması gereken önemli bir ayrım var: bir rutin ateşlendiğinde gerçekte ne oluyor? İki mod var. Basit modda, rutin sadece bir prompt'u modele gönderip cevabı sana bildiriyor — hızlı, ucuz, ama araç kullanamıyor. İstersen o rutin için ajan modunu da açabiliyorsun; bu durumda rutin ateşlendiğinde tam bir agent koşusu başlıyor — dosya okuyabilir, komut çalıştırabilir, WhatsApp mesajı atabilir, hepsi izin sistemi üzerinden. Yani bir rutin, "her sabah 8'de bana günün planını söyle" gibi basit bir prompt da olabilir, "her Pazartesi geçen haftanın notlarını tara ve bir özet dosyası oluştur" gibi tam teşekküllü bir ajan görevi de.

Rutinlerin ürettiği metinler — koşu için modelin kendi sistem promptu, "bugün etkinlik yok" gibi dolgu cümleleri, bildirim başlıkları — artık her zaman Türkçe çıkmak yerine senin gerçek dil ayarını takip ediyor; bu, önceden fark edilmemiş küçük ama can sıkıcı bir tutarsızlıktı.

Saat dilimi konusu, dağıtık bir sistemde her zaman ince bir nokta oluyor — rutinler oluşturuldukları anda yakalanan cihazının saat dilimine göre çalışıyor, sunucununkine göre değil. Seyahat ettiğinde ya da yaz saati değişimi olduğunda bu offset her (yeniden) bağlanışta otomatik olarak yeniden senkronize oluyor — yani rutinin oluşturulduğu günkü saat diliminde donup kalmıyor, kendini düzeltiyor. Mobil tarafta rutin hatırlatıcıları, uygulama o an açık olmasa bile ulaşan gerçek yerel bildirimler olarak geliyor — cihazın kendisinde önceden zamanlanmış, uygulamanın arka planda çalışmasına bağımlı olmayan bildirimler.

Bir çift ince hata daha var, bilmekte fayda var: Memo açıldıktan sonraki ilk dakika içinde vadesi gelen takvim ve rutin hatırlatıcıları eskiden kalıcı olarak kaçırılabiliyordu — hem takvim hem rutin döngüsü, herhangi bir şeyi kontrol etmeden önce kendi ilk iç "tick"ini bekliyordu, yani uygulamayı açtığın an tam da bir hatırlatıcının vadesi gelmişse, o hatırlatıcı hiç tetiklenmeden kayboluyordu. Bu düzeltildi. Ayrıca bir süre Memo, kendi hep-açık takvim/hatırlatma algılamasından habersiz gibi davranıyordu — "benim için hatırlatıcı kurabilir misin" diye doğrudan sorulduğunda, tam da o mesaj için arka planda sessizce bir tane kurarken bile böyle bir sistemi olmadığını söylüyordu. Artık evet diyor — küçük ama kendini tanıma açısından anlamlı bir düzeltme, çünkü bir sonraki bölümün tam konusu da bu.

10Proaktif Öğrenme, Ortamsal Hatırlatmalar ve Kendini Anlama

Buraya kadar anlattığımız her şey, sen bir şey söylediğinde ya da sorduğunda tetikleniyordu. Proaktif öğrenme farklı: Memo'nun, seni nasıl kullandığına dair örüntüleri kendiliğinden fark edip, sen sormasan da nazikçe gündeme getirmesi.

Bunun iki kaynağı var. Biri, doğrudan söylediğin bir alışkanlık — "her akşam saat 9 gibi kod yazıyorum" dediğinde, bu hemen güvenilir bir bilgi olarak kabul ediliyor, birçok oturumda istatistiksel olarak tekrar tekrar çıkması gerekmiyor. Diğeri, pasif olarak gözlemlenen bir örüntü — belirli bir saatte tekrar eden bir davranış, zamanla dairesel bir istatistikle fark ediliyor. Her iki durumda da ortaya çıkan şey aynı: Memo, uygun bir anda ("kod yazma saatin gelmedi mi?" gibi) bunu gündeme getirebiliyor.

Bu gündeme getirme iki şekilde oluyor. Masaüstünde gerçek bir öneri banner'ı var — Evet / Şimdi değil / Sormayı Durdur seçenekleriyle; bu banner önceden sadece görünüp kayboluyordu, bekleyen bir öneriyi görmenin ya da sonradan cevaplamanın hiçbir yolu yoktu, bu artık düzeltildi. Ya da hatırlatma, Memo'nun kendi cevabına doğal şekilde örülü gelebiliyor — ayrı bir banner olarak değil, sohbetin akışı içinde bir cümle olarak. Bunun gerçekten gündeme getirilip getirilmediği, kabul edilip edilmediği ya da geçiştirilip geçiştirilmediği modelin kendisine sorularak değerlendiriliyor — yani belirli bir dilin tam kelimelerine bağlı, kırılgan bir kalıp eşleştirme değil.

Burada önemli bir tasarım kararı var: Memo, olmayan bir örüntüyü uydurmamaya özellikle özen gösteriyor. /insight komutuyla (ya da haftalık bir rutinin sana bunu sormasıyla) Memo'ya doğrudan "beni nasıl görüyorsun" diye sorduğunda, son mood geçmişine ve hafızaya bakıp gerçekten fark ettiği bir şeyi anlatıyor — yeterli veri yoksa bir tane uydurmaması açıkça talimat verilmiş, o durumda tahmin etmek yerine sadece bunu söylüyor. Bu, bir yapay zekanın en cazip ama en tehlikeli eğilimlerinden birine karşı bilinçli bir fren: gerçek bir örüntü yokken bile kulağa akıllıca gelen bir gözlem uydurmak. Memo bunu yapmıyor, en azından yapmaması için özellikle tasarlanmış.

Proaktif öğrenme varsayılan olarak açık geliyor (subtle seviyede) — ama Ayarlar → Genel'den tamamen kapatabilirsin, ya da daha ince taneli bir şekilde, Minimal Mod'un içindeki alt anahtarlardan sadece bunu kapatabilirsin. Minimal Mod, yerel modelini olabildiğince az ek yükle çalıştırmak isteyenler için var — açıkken Memo kişilik, mood ve web arama talimatlarının tamamını atlıyor, sadece hafıza (o da ayrıca açıksa) modele gidiyor. Eskiden bu hep-ya-da-hiç bir anahtardı; artık dört ayrı parçaya bölünmüş durumda — kişilik/sistem promptu, yetenek açıklamaları, pasif-özellik açıklamaları, ve proaktif öğrenme — her biri, Minimal Mod diğer her şeyiyle açıkken bile tek tek yeniden açılabiliyor. Bu katmanlı geçersiz kılma, "en hafif çalışsın ama proaktif hatırlatmalar hâlâ gelsin" gibi karma tercihlere izin veriyor.

Gizli moddayken bu sistemin tamamı kapalı, hiçbir istisna yok. Minimal moddayken de, sen özellikle yeniden açmadıkça, kapalı kalıyor — mantık şu: en hafif, en az konuşkan modu seçtiysen, muhtemelen sohbetin ortasına serpiştirilmiş öneriler de istemiyorsundur.

11Başka Bir Yapay Zekadan Hafıza Aktarımı

Yeni bir asistana geçtiğinde en can sıkıcı şey, sıfırdan başlamak. Aylarca ChatGPT'ye ya da Gemini'ye anlattığın şeyleri, Memo'ya tekrar tekrar anlatmak zorunda kalmak istemezsin. Hafıza İçe Aktarımı tam bunun için var — tek seferlik bir bootstrap özelliği.

Nasıl çalıştığı basit: Memo sana hazır bir prompt veriyor, sen bunu kopyalayıp diğer yapay zekayla (hangisini kullanıyorsan) olan sohbetine yapıştırıyorsun. Bu prompt o yapay zekadan seni yapılandırılmış bir şekilde anlatmasını istiyor — demografi, ilgi alanların, ilişkilerin, yaklaşan etkinliklerin/planların, iletişim tarzın, standart talimatların. Diğer yapay zekanın cevabını kopyalayıp Memo'ya geri yapıştırıyorsun, "Hafızaya İşle"ye basıyorsun. Memo bu metni o an aktif olan modeline gönderiyor (yerel model ya da dış API, hangisi aktifse), model onu ayrı ayrı atomik gerçeklere bölüp her birini /remember gibi kaydediyor. Ayrıca "seninle nasıl konuşulmasını istediğin" özeti ayrı bir şekilde Memo'nun kendi sistem promptuna kalıcı olarak katlanıyor — olasılıksal bir hatırlama olarak değil, bir gerçek gibi.

Burada anlaşılması gereken önemli bir nokta: bu özellik, sana ne kadar verirsen o kadar veriyor. İnce bir sohbet geçmişi, ince bir sonuç veriyor. Eğer diğer yapay zekayla henüz çok az konuşmuşsan, ondan isteyeceğin özet de doğal olarak zayıf, neredeyse boş çıkacaktır — çünkü o yapay zeka da seni henüz tanımıyordur. Memo bu konuda dürüst bir uyarı gösteriyor: önce diğer yapay zekayla biraz sohbet etmiş olman gerektiğini hatırlatan bir banner. Bunu atlayıp hemen denersen, aktarılan "hafıza" da o kadar sığ olur — bu özelliğin bir kusuru değil, mantıksal bir sınırı.

12Yedekleme, Bulut Senkronu ve Geri Yükleme

Bir gün bilgisayarın bozulabilir, ya da yeni bir bilgisayara geçebilirsin. Memo'nun .memo dışa aktarım formatı, tam olarak bu senaryo için var — tüm verilerini tek bir zip arşivine paketleyen bir yedekleme sistemi.

Bu arşivin içinde artık gerçekten her şey var: sohbet oturumların, yapılandırman, şifrelenmiş sağlayıcı anahtarların (ve onları çözen machine.key — bir önceki bölümde bahsettiğimiz, uzun süre eksik olan parça), ajan izin politikaların, orkestra yapılandırman, hafıza deposunun tamamı, takvimin, öğrenilen alışkanlıkların, rutinlerin, görev listelerin, kullanım istatistiklerin, ajan dosya-düzenleme güvenlik yedeklerin, kurulu skill'lerin, ve WhatsApp verilerin. Modellerin kendisi isteğe bağlı bir bayrakla (includeModels) dahil edilebiliyor — genelde bunları dahil etmemek daha mantıklı, çünkü zaten birkaç gigabaytlık dosyalar ve yeniden indirilebilirler.

Bilinçli olarak dışarıda bırakılan üç şey var, ve bunun sebebini bilmek işine yarar: cihaza özel Google Drive senkron imleci (başka bir kuruluma taşınırsa senkronunu yanlış yola sokabilir), makineye özel Tailscale kimliği, ve yedeklemenin kendi anlık görüntü dizini (dahil etmek eski yedekleri yenisinin içine iç içe koyardı). Bunlar unutkanlık değil, bilinçli tasarım kararları.

Bulut senkronu, bu fikri bir adım öteye taşıyor: Google Drive üzerinde uçtan uca şifreli, otomatik bir yedekleme. Her N mesajda bir (varsayılan 50), Memo sessizce verilerini bir pakete dönüştürüyor, senin belirlediğin bir parolayla (AES-256-GCM, PBKDF2 ile 600.000 yinelemeli anahtar türetme) şifreliyor, ve Google Drive'ının gizli uygulama verisi klasörüne yüklüyor. Buradaki kritik nokta: şifreleme senin makinende, veriler Drive'a çıkmadan önce yapılıyor — Google, elindeki dosyayı asla okuyamıyor, sadece anlamsız bir bayt yığını görüyor. Bunun bir bedeli var, ve bunu çok açık söylemek gerek: parolanı unutursan, geri dönüş yok. Bu parola bir yerde saklanmıyor, Memo'nun kendisinde de değil — sadece sende. Yeni bir bilgisayara geçtiğinde aynı Client ID/Secret ve aynı parolayla giriş yapıp "Pull from Cloud" dediğinde her şeyin eskisi gibi geri geldiğini görüyorsun; ama parolayı unutmuşsan, o yedek sonsuza dek kilitli kalıyor.

13Gizlilik ve Güvenlik Duruşu

Memo'nun bütün mimarisi bir varsayımdan doğuyor: verinin senin olması gerekir, kimsenin değil. Bunu somutlaştıran birkaç farklı katman var.

Gizli Mod, sıfır kalıcılık ilkesiyle çalışıyor — açtığın an, konuşman semantik hafızaya hiç kaydedilmiyor, oturum geçmişi diske hiç yazılmıyor, her şey sadece o oturumun RAM'i içinde yaşayıp uygulama kapanınca yok oluyor. Şifreler içeren bir kod bloğu üzerinde çalışırken, ya da asistanının kalıcı hafızasını kirletmek istemediğin rastgele bir konuda, sohbet çubuğundaki göz ikonuna basman yeterli. Minimal Mod ise farklı bir eksende çalışıyor — o gizlilik değil, sadelik/performans için: kişilik, mood ve web arama talimatlarını atlayarak modele giden yükü en aza indiriyor; hafıza isterse hâlâ açık kalabiliyor. İkisi karıştırılmamalı — biri "hiçbir şey kaydetme", diğeri "modele gereksiz yere fazla şey gönderme".

Uzaktan erişim (LAN üzerinden ya da ngrok ile) açıldığında, artık her isteğin bir erişim token'ı sunması zorunlu. Bu, göründüğünden daha ciddi bir düzeltme — daha önce, o adrese ulaşabilen herkes (aynı Wi-Fi ağındaki biri, ya da elinde ngrok linki olan biri) hiçbir kimlik doğrulaması yapmadan sağlayıcı API anahtarlarını okuyabiliyor, verilerini silebiliyor, hatta makinende komut çalıştırabiliyordu. Mobil uygulama bu token'ı zaten gönderiyor, bu yüzden onun için hiçbir şey değişmedi; sadece yerel kullanım (varsayılan, uzaktan erişim kapalıyken) bundan hiç etkilenmiyor.

Şifreleme tarafında birkaç farklı katman var, ve her birinin farklı bir anahtarı olduğunu bilmek kafa karışıklığını önler: sağlayıcı API anahtarların makineye özel bir anahtardan türetilen AES-256-GCM ile şifreleniyor (taşınabilir değil — bu yüzden bir önceki bölümde bahsettiğimiz machine.key meselesi önemli); bulut senkron verilerin ise senin belirlediğin bir parolayla şifreleniyor (taşınabilir, ama parolayı unutursan kurtarılamaz).

Ajan modunun altındaki sandbox, daha önce bahsettiğimiz gibi, dosya sistemi erişimini çalışma dizinine sınırlıyor, komutları bir zaman aşımıyla kısıtlıyor, ve tehlikeli komut kalıplarını daha çalışmadan yakalıyor. Buradaki en öğretici örnek belki de symlink-kaçış düzeltmesiydi: proje içinde henüz var olmayan bir hedefe işaret eden bir symlink, teorik olarak bir dosya-düzenleme aracının sandbox'lanmış proje dizini dışına yazmasına izin verebiliyordu. Bu, "sandbox var diye güvenliyiz" varsayımının ne kadar kırılgan olabileceğinin iyi bir örneği — bulunup kapatıldı, ama bunun varlığı bile, güvenlik sınırlarının statik değil, sürekli test edilip düzeltilmesi gereken şeyler olduğunu hatırlatıyor.

14Mobil Uygulama ve Uzaktan Erişim

Mobil uygulamayı en iyi anlatan cümle şu: telefonun bir uzaktan kumanda, kopya değil. Tüm ağır iş — model çıkarımı, RAG araması, embedding — masaüstünde oluyor; telefon sadece yazdığını gönderiyor ve cevabı gösteriyor. Bu yüzden telefonun eski, yavaş, pili zayıf olsa bile fark etmiyor — hiçbir model onun üzerinde çalışmıyor.

En basit bağlantı yöntemi aynı Wi-Fi ağında olmak (LAN). Bilgisayarının IP adresini öğrenip mobil uygulamaya giriyorsun, ya da IP'yi bilmiyorsan "Tara" butonuyla telefonun ağdaki Memo'yu otomatik bulmasını sağlıyorsun. Bunun sınırı net: sadece aynı ev/ofis ağında çalışıyor, dışarıdan bağlanamıyorsun.

Dışarıdan bağlanmak istediğinde iki seçenek var. Ngrok en kolay yol — bir hesap açıp auth token'ını Memo'ya giriyorsun, Memo sana geçici bir URL veriyor, o URL'yi telefonuna giriyorsun. Bedeli şu: ücretsiz ngrok'ta bu URL her başlatmada değişiyor, yani her seferinde yeni URL'yi elle girmen gerekiyor. Tailscale ise daha kararlı bir çözüm — bir kere kurduğunda, sabit bir hostname üzerinden (örneğin memo-ev) hep aynı adresle bağlanabiliyorsun; bedeli, biraz daha fazla ilk kurulum adımı. İkisi de Ayarlar → Uzaktan Erişim'den (Tailscale artık Beta Özellikler'in altında) açılıyor, ve her ikisinde de token koruması şiddetle önerilir — özellikle ngrok gibi herkese açık bir tünel kullanıyorsan.

Uzun süre uzaktan erişim token'ı, masaüstü uygulaması yeniden başlatıldığında unutuluyordu — ilk isteğin çalışması için token'ı elle tekrar girmen gerekiyordu. Bu artık düzeltildi, token uygulama yeniden başlasa da hayatta kalıyor.

15Geliştirici API Ağ Geçidi: Memo'yu Başka Bir Araçtan Kullanmak

Bu, teknik kullanıcılar için ayrılmış bir özellik ve biraz farklı bir açıdan bakmayı gerektiriyor. Claude Code gibi araçlar sadece Anthropic'in Messages API formatını konuşabiliyor — başka bir sağlayıcıyı doğrudan bağlayamıyorsun. Geliştirici API Ağ Geçidi, Memo'yu bu iki tarafın arasına koyuyor: dışarıdan Anthropic formatında bir istek geliyor, Memo bunu kendi iç temsiline çeviriyor, hangi backend'e (yerel model ya da tanımlı bir sağlayıcı) gideceğine karar veriyor, cevabı alıp tekrar Anthropic formatına çevirip geri gönderiyor.

Pratikte bunun açtığı kapı şu: Claude Code'u ANTHROPIC_BASE_URL ayarıyla Memo'ya işaret ediyorsun, ve arkada aslında kendi yerel modelini ya da kendi OpenAI/Gemini API anahtarını kullanıyorsun — Claude Code'un arayüzünü ve iş akışını korurken, faturalandırmayı ve model seçimini tamamen kendi kontrolüne alıyorsun. Model seçimi tip/model-id formatında yapılıyor — local/qwen2.5 yüklü bir yerel modeli işaret ediyor, openai/gpt-4o etkin bir OpenAI sağlayıcısını. Tam agentic araç çağırma (dosya okuma/yazma, komut çalıştırma) gerçekten çalışıyor — ama sadece openai/custom/local/groq/openrouter/grok/opencode-zen/opencode-go sağlayıcıları için; gemini/claude/ollama tiplerinin kendi provider implementasyonları hiç araç desteklemediği için, bu üçünden birine araç tanımlı bir istek gelirse sessizce yutmak yerine açık bir hata dönülüyor.

Bu ağ geçidi varsayılan olarak API anahtarı istemiyor (Uzaktan Erişim'in token'ıyla aynı mekanizma, o da varsayılan kapalı) ve hafıza entegrasyonu da varsayılan kapalı. Hafızayı açarsan bile, bu ağ geçidi üzerinden geçen trafik asla görünür bir sohbet oturumu oluşturmuyor — Claude Code üzerinden yaptığın bir kodlama sohbeti, Memo'nun kendi sohbet geçmişinde hiçbir zaman görünmüyor. Bu, ağ geçidi trafiğiyle gerçek sohbetlerin birbirine karışmaması için bilinçli bir tasarım kararı. Ekranın kendisi Ayarlar'ın içinde değil, yan navigasyon çubuğunda kendi başına duruyor — Base URL, model listesi, token, ve ağ geçidinden geçen her isteği canlı gösteren bir günlük ile.

Pratikte kurulumu bir dakikadan az sürüyor. Geliştirici ekranını aç, Base URL'i kopyala (varsayılan olarak http://localhost:8090), ve Claude Code'u çalıştırmadan önce bunu bir ortam değişkeni olarak ayarla — yanına, Claude Code'un kendi SDK'sının bir şey ayarlanmadan başlamayı reddettiği (Memo, API Anahtarı Gerektir'i açmadığın sürece bunu hiç kontrol etmese bile) bir yer tutucu API anahtarı ve başlangıçta kullanmasını istediğin tip/model-id değerini ekleyerek:

export ANTHROPIC_BASE_URL="http://localhost:8090"
export ANTHROPIC_API_KEY="not-needed"
export ANTHROPIC_MODEL="local/qwen2.5"

Buradan sonra claude'u her zamanki gibi çalıştırman yeterli — görünüşünde ya da hissinde hiçbir şey değişmiyor, çünkü kendi SDK'sı açısından gerçek Anthropic API'siyle konuştuğunu sanıyor. Oturum ortasında model değiştirmek Claude Code'un kendi /model komutuyla çalışıyor (/model openai/gpt-4o gibi), ve Geliştirici ekranının canlı günlüğü, ilk isteğinin gerçekten ulaşıp ulaşmadığını, ikisi arasında bir yerde sessizce kaybolmadığını doğrulamanın en hızlı yolu.

16Memo Swarm (Beta): Birden Fazla Bilgisayarı Birleştirmek

Bazı GGUF modeller o kadar büyük ki, tek bir bilgisayarın belleğine hiç sığmıyor. Memo Swarm, bunun için evdeki ya da ofisteki birkaç bilgisayarı bir takım gibi kullanmanı sağlıyor. Bir bilgisayar Host (ev sahibi) oluyor — model dosyası onda kalıyor, bir oda açıyor, kısa bir oda kodu paylaşıyor. Diğer bilgisayarlar bu kodla katılıyor; modele hiç dosya indirmiyorlar, sadece işlem gücü katıyorlar. Teknik olarak bu, llama.cpp'nin hazır RPC özelliğinin (rpc-server + host tarafında --rpc) yönetilmesi — Memo dağıtık hesaplama motorunu sıfırdan yazmıyor, var olan bir mekanizmayı düzgün bir arayüzle sarıyor.

Kimin için olduğunu net söylemek gerekirse: bu, günlük kullanıcı için değil. Bu, elinde büyük bir model dosyası olan ama tek bir makinenin VRAM/RAM'ine sığdıramayan, ve evinde/ofisinde birkaç boşta bilgisayar bulunan biri için. Amaç hız değil, kapasite — birlikte çalışan makineler genelde tek başına aynı modeli çalıştırabilecek bir makineden daha yavaş token üretiyor, ama tek başına hiç açılamayacak bir model, birlikte mümkün hale geliyor. Her makinenin payını yüzde olarak sen ayarlıyorsun; hepsi sıfırsa fiilen bir havuzlama olmuyor.

Mevcut sınırlamaları dürüstçe söylemek lazım: macOS'ta henüz yok — gerekli RPC yardımcı programı o platformda paketlenmiyor. Makinelerin birbirini ağ üzerinden görmesi gerekiyor (aynı Wi-Fi/LAN, ya da uzak siteler için her iki tarafta da sistem seviyesinde bir Tailscale gibi bir yol — Memo'nun kendi gömülü Tailscale tüneli sadece HTTP erişimine yardımcı oluyor, RPC trafiği ayrı bir OS-seviyesi TCP bağlantısı gerektiriyor). Ve açıkça beta — Host/Katıl arayüzü ve süreç yönetimi hâlâ olgunlaşıyor, gerçek çok-makineli donanım testleri kullanıcıların kendi ortamlarına bağlı olarak devam ediyor.

17Kullanım İstatistikleri ve Kapanış Düşünceleri

Ayarlar → İstatistikler sekmesi, Memo'yu ne kadar kullandığını sana geri gösteren sessiz bir ayna: toplam istek sayısı, toplam girdi/çıktı token, ortalama token/saniye hızı, en çok kullandığın model — üstte kartlar halinde; altında son 30 günün günlük token kullanımını gösteren yığılmış bir bar grafik ve model bazında kullanım dağılımı. Backend, gizli mod hariç, her tamamlanan sohbet turunu (yerel model, ajan, orkestra ya da dış sağlayıcı fark etmeksizin) kendi ayrı veritabanına kaydediyor. Bilinçli olarak gösterilmeyen tek şey maliyet ($) — çünkü hiçbir sağlayıcı backend tarafında gerçek fiyat verisi sunmuyor, ve sahte ya da bakımsız kalacak bir tabloyu eklemektense bu alan bilerek boş bırakılmış.

Bu bölümü bitirmeden, en başta söylediğimiz şeye geri dönmek istiyorum. Memo'nun her özelliği — hafızası, ajan modu, orkestrası, provider seçimi — aynı tek fikrin farklı yansımaları: veri senin, makine senin, model seçimi senin. Bir bulut asistanı sana "en iyi deneyim" için belirli bir modeli, belirli bir gizlilik politikasını, belirli bir fiyatlandırmayı dayatır. Memo hiçbirini dayatmıyor — küçük bir yerel model mi istersin, yoksa en pahalı bulut modeli mi, hiç fark etmez, karar senin elinde kalıyor.

Bunu söylerken şunu da unutmamak lazım: bu kılavuzda okuduğun her düzeltme, her "eskiden böyleydi, şimdi düzeltildi" cümlesi, aslında tek bir kişinin — 16 yaşında bir yazılımcının — gerçek kullanıcı geri bildirimlerine göre bir ürünü büyütme çabasının izi. Bu hem bir uyarı hem bir davet: bazı köşeler büyük şirketlerin ürünleri kadar cilalı olmayabilir, ama her hata raporu gerçekten okunuyor, her sürüm notu gerçek bir değişikliği anlatıyor. Memo, aktif olarak geliştirilen bir açık kaynak proje — ve bir sonraki sürüm notlarını okuduğunda, muhtemelen bugün karşılaştığın küçük bir tuhaflığın da orada, düzeltilmiş olarak karşına çıktığını göreceksin.

Zihnin sınırsız, verilerin egemen — geri kalanı, seçtiğin modele bağlı.