Yapay Zeka Ajanlarına Kalıcı Hafıza Ekleme (Dününü Hatırlaması İçin)

TL;DR

Yapay zeka ajanlarına 4 adımda kalıcı bellek ekleyin: (1) remember, recall, search ve rollback araçlarıyla bir MCP bellek sunucusu kurun, (2) Ajan istemlerine bellek talimatları ekleyin, (3) Claude Code için ~/.claude/settings.json veya Cursor için .cursor/mcp.json dosyasını yapılandırın, (4) Karar kaydı, ajan devirleri ve oturum kontrol noktaları için bellek kalıplarını kullanın. Ajanlar oturumlar arası bağlamı korur; artık önceki konuşmaları kopyala-yapıştırmaya gerek yok.

Apidog'u bugün deneyin

“Dünü hatırlamıyorum” sorununu çözün. MCP protokolünü kullanarak yapay zeka ajanlarına kalıcı bellek ekleyin, böylece önceki oturumlardaki kararları, teslim edilebilirleri ve bağlamı hatırlayacaklar.

Sistemi biliyorsunuz:

Day 1: "Build the user authentication system"
Agent: [Builds JWT auth, creates users table, implements refresh tokens]

Day 2: "Continue from yesterday"
Agent: "I don't have context from previous sessions. Can you paste what we did?"

Önceki konuşmayı kopyalayıp yapıştırıyorsunuz. Ajan 2000 satır bağlamı okuyor. İkiniz de hızlanmak için 15 dakika harcıyorsunuz.

Kalıcı bellek bunu düzeltir. MCP (Model Bağlam Protokolü) belleği ile ajanlar kararları otomatik olarak depolar ve gerektiğinde geri çağırır. Kopyala-yapıştır yok. Yeniden açıklama yok.

Bu eğitimde, yapay zeka ajanları için MCP belleği kuracaksınız. Backend Architect oturumlarından alınan kararları nasıl depolayacağınızı, Database Optimizer'a geçerken bağlamı nasıl geri çağıracağınızı ve Frontend Developer'a teslim edilebilirleri nasıl devredeceğinizi—tüm bunları bağlamı kaybetmeden—öğreneceksiniz. Aynı bellek kalıpları, Apidog entegrasyonu ile API'ler oluşturuyor veya çok günlük geliştirme sprintlerini yönetiyor olsanız da işe yarar.

MCP Belleği Nedir?

MCP belleği, yapay zeka ajanlarının oturumlar arasında bilgi depolamasını ve almasını sağlar. Bunu, ajanların yazıp okuyabileceği ortak bir not defteri gibi düşünün.

MCP belleğini destekleyen dört ana araç:

Araç	Amaç	Örnek
remember	Bilgiyi etiketlerle depola	"UUID, bcrypt ile kullanıcı tablosu"nu kaydet
recall	Anahtar kelimeye veya etikete göre ara	"auth kararları"nı bul
rollback	Önceki duruma geri yükle	Hatalı şema değişikliklerini geri al
search	Oturumlar arasında ara	"Backend Architect neye karar verdi?"

┌─────────────────┐         ┌──────────────────┐         ┌─────────────┐
│  AI Agent       │         │  MCP Memory      │         │  Storage    │
│  (Claude Code)  │◄───────►│  Server          │◄───────►│  (SQLite)   │
└─────────────────┘   JSON  └──────────────────┘  I/O    └─────────────┘

---

Adım 1: Bir MCP Bellek Sunucusu Kurun

Bellek araçlarını kullanabilmek için bir MCP sunucusu kurmanız gerekir. İki pratik yolunuz var:

Seçenek A: Barındırılan bir bellek sunucusu kullanın

npm install -g @example/mcp-memory-server

Seçenek B: Kendi yerel sunucunuzu yazın

memory-server.js dosyası oluşturun:

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import fs from "fs/promises";
import path from "path";

const MEMORY_FILE = path.join(process.env.HOME, ".mcp-memory", "memories.json");

const server = new McpServer({
  name: "memory",
  version: "1.0.0"
});

// Ensure memory file exists
async function initMemory() {
  await fs.mkdir(path.dirname(MEMORY_FILE), { recursive: true });
  try {
    await fs.access(MEMORY_FILE);
  } catch {
    await fs.writeFile(MEMORY_FILE, JSON.stringify([]));
  }
}

// Tool: remember
server.tool(
  "remember",
  {
    content: z.string().describe("Information to store"),
    tags: z.array(z.string()).describe("Tags for retrieval (e.g., ['backend', 'auth'])"),
    agent: z.string().optional().describe("Agent name for tagging")
  },
  async ({ content, tags, agent }) => {
    await initMemory();
    const memories = JSON.parse(await fs.readFile(MEMORY_FILE, "utf-8"));
    const memory = {
      id: Date.now().toString(),
      content,
      tags,
      agent,
      timestamp: new Date().toISOString()
    };
    memories.push(memory);
    await fs.writeFile(MEMORY_FILE, JSON.stringify(memories, null, 2));
    return { content: [{ type: "text", text: `Stored memory with tags: ${tags.join(", ")}` }] };
  }
);

// Tool: recall
server.tool(
  "recall",
  {
    query: z.string().describe("Search query or tag to find"),
    agent: z.string().optional().describe("Filter by agent name")
  },
  async ({ query, agent }) => {
    await initMemory();
    const memories = JSON.parse(await fs.readFile(MEMORY_FILE, "utf-8"));
    const results = memories.filter(m =>
      (m.content.toLowerCase().includes(query.toLowerCase()) ||
       m.tags.some(t => t.toLowerCase().includes(query.toLowerCase())))
      && (!agent || m.agent === agent)
    );
    return {
      content: [{
        type: "text",
        text: results.length === 0
          ? "No memories found"
          : results.map(m => `[${m.timestamp}] ${m.content}`).join("\n\n")
      }]
    };
  }
);

// Tool: search
server.tool(
  "search",
  {
    tags: z.array(z.string()).describe("Tags to search for"),
    limit: z.number().optional().default(10)
  },
  async ({ tags, limit }) => {
    await initMemory();
    const memories = JSON.parse(await fs.readFile(MEMORY_FILE, "utf-8"));
    const results = memories
      .filter(m => tags.some(t => m.tags.includes(t)))
      .slice(0, limit);
    return {
      content: [{
        type: "text",
        text: results.map(m => `[${m.agent || "unknown"}] ${m.content}`).join("\n\n")
      }]
    };
  }
);

// Tool: rollback
server.tool(
  "rollback",
  {
    agent: z.string().describe("Agent name to rollback"),
    timestamp: z.string().describe("Rollback to this timestamp")
  },
  async ({ agent, timestamp }) => {
    await initMemory();
    const memories = JSON.parse(await fs.readFile(MEMORY_FILE, "utf-8"));
    const rolledBack = memories.filter(m =>
      m.agent !== agent || new Date(m.timestamp) <= new Date(timestamp)
    );
    await fs.writeFile(MEMORY_FILE, JSON.stringify(rolledBack, null, 2));
    return {
      content: [{
        type: "text",
        text: `Rolled back ${agent} to ${timestamp}`
      }]
    };
  }
);

const transport = new StdioServerTransport();
await server.connect(transport);

Sunucuyu başlatın:

node memory-server.js

---

Adım 2: Herhangi Bir Ajana Bellek Talimatları Ekleyin

Ajan dosyalarını değiştirmeden bellek protokolünü kullanabilirsiniz. İstemlerinize aşağıdaki gibi talimatlar ekleyin:

Yapay zeka bellek araçlarına erişiminiz var: remember, recall, search, rollback.

Bu bellek protokollerini uygulayın:

**Bir oturum başlattığınızda:**
1. Bağlamı geri çağırın: recall(query="ecommerce-api", agent="Backend Architect")
2. Son oturumdan kalan bekleyen öğeleri gözden geçirin

**İşi tamamladığınızda:**
1. Teslim edilebilirleri etiketlerle kaydedin:
   - remember(content="UUID birincil anahtarlı kullanıcı tablosu, bcrypt parola hash'leme, yenileme belirteçleriyle JWT kimlik doğrulaması oluşturuldu", tags=["ecommerce-api", "database", "auth"], agent="Backend Architect")
2. Alınan kararları ve bekleyen öğeleri dahil edin

**Başka bir ajana devrettiğinizde:**
1. Alıcı ajan için bağlam bırakın:
   - remember(content="API uç noktaları: /auth/login, /auth/register, /products, /orders. Kimlik doğrulama akışı: JWT erişim belirteci (15dk) + yenileme belirteci (7 gün). Bilinen sorun: hız sınırlaması henüz uygulanmadı", tags=["ecommerce-api", "handoff"], agent="Backend Architect", for="Frontend Developer")

**Bir şeyler başarısız olduğunda:**
1. Son bilinen iyi durumu arayın
2. Geri yüklemek için rollback kullanın

Pratik örnek:

You: "Backend Architect modunu etkinleştir. E-ticaret API'mız için kullanıcı sistemini tasarla."

[Agent sistemi tasarlar, şema oluşturur, kimlik doğrulamayı uygular]

Agent: "Kullanıcı sistemi tamamlandı. Bellek depolanıyor..."
→ Çağırır: remember("UUID, bcrypt, JWT + yenileme belirteçleriyle kullanıcı tablosu", tags: ["ecommerce-api", "auth", "database"])

[Oturum sona erer]

[Ertesi gün]

You: "Dünden devam et"

Agent: "Bağlam geri çağrılıyor..."
→ Çağırır: recall(query="ecommerce-api")
→ Döndürür: "UUID, bcrypt, JWT + yenileme belirteçleriyle kullanıcı tablosu"

Agent: "Dün UUID birincil anahtarlı kullanıcı tablosunu tasarladım, bcrypt parola hash'lemeyi uyguladım ve yenileme belirteçleriyle JWT kimlik doğrulamasını kurdum. Sonraki adım: ürün kataloğu şeması. Devam etmeye hazır."

---

Adım 3: Claude Code İçin Yapılandırın

Bellek sunucusunu Claude Code'a eklemek için:

~/.claude/settings.json dosyanızı şu şekilde güncelleyin:

{
  "mcpServers": {
    "memory": {
      "command": "node",
      "args": ["/absolute/path/to/memory-server.js"],
      "env": {
        "HOME": "/Users/your-username"
      }
    }
  }
}

Claude Code'u yeniden başlatın. Bellek araçları artık kullanılabilir.

Test:

remember aracı ile "E-ticaret projesi için test belleği" kaydedin
Tags: ["test", "ecommerce-api"]

recall aracı ile "test" etiketli anıları sorgulayın

---

Adım 4: Cursor İçin Yapılandırın

Projenizin köküne .cursor/mcp.json dosyası ekleyin:

{
  "mcpServers": {
    "memory": {
      "command": "node",
      "args": ["/absolute/path/to/memory-server.js"]
    }
  }
}

Test:

@memory remember "PostgreSQL ile e-ticaret API projesi başlatılıyor"
Tags: ["ecommerce-api", "setup"]

@memory recall query="ecommerce"

---

Gerçek İş Akışları İçin Bellek Kalıpları

Kalıp 1: Karar Günlüğü

Her teknik kararı aşağıdaki gibi kaydedin:

remember({
  content: "PostgreSQL'i MySQL yerine seçme nedenleri: (1) Esnek ürün nitelikleri için JSONB desteği, (2) daha iyi tam metin arama, (3) yerel UUID desteği",
  tags: ["ecommerce-api", "database", "decision"],
  agent: "Backend Architect"
})

Daha sonra:

recall(query="PostgreSQL MySQL karar")

Kalıp 2: Ajan Devirleri

Ajan değiştirirken devri not alın:

remember({
  content: "Backend tamamlandı. Uç noktalar: POST /auth/login, POST /auth/register, GET /products, POST /orders. Kimlik doğrulama: JWT 15dk erişim + 7 gün yenileme. Bekleyenler: hız sınırlaması, e-posta doğrulama. Frontend ihtiyaçları: giriş formu, ürün listesi, sepet, ödeme.",
  tags: ["ecommerce-api", "handoff", "backend-complete"],
  agent: "Backend Architect",
  for: "Frontend Developer"
})

Frontend Developer başlarken:

recall(query="handoff", agent="Backend Architect")

Kalıp 3: Oturum Kontrol Noktaları

Her oturum sonunda:

remember({
  content: "Oturum tamamlandı. Yapılanlar: kullanıcı tablosu, kimlik doğrulama uç noktaları, ürün şeması. Sonraki oturum: sipariş sistemi, ödeme web kancası. Engelleyiciler: Stripe API anahtarları bekleniyor.",
  tags: ["ecommerce-api", "checkpoint", "session-1"],
  agent: "Backend Architect"
})

Sonra:

recall(query="checkpoint session-1")

Kalıp 4: Hata Takibi

Bir hata bulunca:

remember({
  content: "HATA: Çıkış yaptıktan sonra yenileme belirteci sona ermiyor. Belirteç bellekte depolanıyor, kalıcı değil. Düzeltme: Redis'e TTL ile taşı.",
  tags: ["ecommerce-api", "bug", "auth"],
  agent: "Code Reviewer",
  severity: "high"
})

Aramak için:

search(tags=["bug", "ecommerce-api"])

---

Sorun Giderme

Bellek kalıcı olmuyor:

• Bellek dosyası yolunu kontrol edin (~/.mcp-memory/memories.json)
• MCP sunucusunun çalıştığından emin olun
• Claude Code/Cursor'ın MCP yapılandırmasını doğrulayın

Geri çağırmada çok fazla sonuç:

• Daha spesifik etiketler ekleyin
• Ajan adına göre filtreleyin
• Tırnak içinde tam ifadeler kullanın

Bellek dosyası büyüyor:

• Eski anıları periyodik olarak arşivleyin
• Tamamlanan projeleri temizlemek için rollback kullanın
• Bellek verinize son kullanma tarihi ekleyin

---

Neler Yaptınız?

Bileşen	Amaç
MCP Bellek Sunucusu	Oturumlar arasında bilgileri depolama/geri alma
remember aracı	Kararları, teslim edilebilirleri, devirleri kaydetme
recall aracı	Önceki oturumlardan bağlam bulma
search aracı	Tüm anılar arasında etiketlere göre sorgulama
rollback aracı	Gerektiğinde önceki duruma geri yükleme
Bellek kalıpları	Karar kaydı, devirler, kontrol noktaları, hata takibi

---

Sonraki Adımlar

Bellek sunucusunu genişletmek için:

• Gömme ile anlamsal arama ekleyin
• Bellek sona erme (30 gün sonra otomatik arşivleme) uygulayın
• Bellek özetleme (uzun oturumları yoğunlaştırma) ekleyin

Ekip belleği oluşturmak için:

• Merkezî bir bellek sunucusu paylaşın
• Anıları projeye ve geliştiriciye göre etiketleyin
• Yeni ekip üyeleri için işe alım akışları oluşturun

Araç entegrasyonu için:

• Git commit'lerini otomatik anı olarak kaydedin
• Proje yönetimi araçları (Jira, Linear) ile senkronize edin
• Anıları dökümana aktarın

---

Yaygın Sorun Giderme

Bellek oturumlar arasında kalıcı olmuyor:

• Claude Code'u başlatmadan önce MCP sunucusunun çalıştığını kontrol edin
• Bellek dosyası yolunun mevcut olduğunu doğrulayın: ls -la ~/.mcp-memory/memories.json
• Dosya izinlerinin okuma/yazmaya izin verdiğinden emin olun: chmod 644 ~/.mcp-memory/memories.json
• ~/.claude/settings.json içindeki sunucu yolunun doğru olduğundan emin olun

Geri çağırma boş sonuç dönüyor:

• Sorgunun depolanan etiketlerle eşleştiğini kontrol edin (büyük/küçük harf duyarlı)
• Daha genel aramalar veya belirli etiketlerle search deneyin
• Anıların kaydedildiğini doğrulayın: cat ~/.mcp-memory/memories.json
• agent filtresi aktifse doğru ajan adını kullandığınızdan emin olun

Bellek dosyası çok büyüyor:

• 30 günden eski anılar için otomatik arşivleme uygulayın
• Tarih aralığına göre silme yapan bir prune aracı ekleyin
• Anıları projeye veya tarihe göre ayrı dosyalara bölün
• Büyük ölçekli kullanımda JSON yerine SQLite gibi bir veritabanı arka ucu kullanın

Sunucu başlatılamıyor:

• Node.js sürümünü kontrol edin: node --version (18+ olmalı)
• Eksik bağımlılıkları yükleyin: npm install @modelcontextprotocol/sdk zod
• Sunucu kodunda sözdizimi hatalarını kontrol edin
• Hataları görmek için doğrudan çalıştırın: node memory-server.js

Birden fazla ajan birbirinin anılarını üzerine yazıyor:

• remember çağrılarında mutlaka agent alanını doldurun
• Proje başına benzersiz etiketler kullanın: ["project-x", "backend", "auth"]
• Geri çağırırken ajan adına göre filtreleyin
• Gerekirse proje başına ayrı bellek dosyaları kullanın

---

Bellek Sunucusu Güvenlik Hususları

API Anahtarı Depolama: Hassas veriler (API anahtarları, parolalar) kaydediyorsanız, şifreleme uygulayın:

import crypto from 'crypto';

const ENCRYPTION_KEY = process.env.MEMORY_ENCRYPTION_KEY;
const ALGORITHM = 'aes-256-gcm';

function encrypt(text) {
  const iv = crypto.randomBytes(16);
  const cipher = crypto.createCipheriv(ALGORITHM, Buffer.from(ENCRYPTION_KEY), iv);
  const encrypted = cipher.update(text, 'utf8', 'hex');
  return {
    encryptedData: encrypted + cipher.final('hex'),
    iv: iv.toString('hex'),
    authTag: cipher.getAuthTag().toString('hex')
  };
}

function decrypt(encrypted) {
  const decipher = crypto.createDecipheriv(
    ALGORITHM,
    Buffer.from(ENCRYPTION_KEY),
    Buffer.from(encrypted.iv, 'hex')
  );
  decipher.setAuthTag(Buffer.from(encrypted.authTag, 'hex'));
  return decipher.update(encrypted.encryptedData, 'hex', 'utf8') + decipher.final('utf8');
}

Erişim Kontrolü: Ekip bellek sunucularında kimlik doğrulama ekleyin:

• Bellek aracı çağrılarında API anahtarı isteyin
• Kullanıcıya özel namespace kullanın
• Tüm bellek işlemlerini denetim amaçlı kaydedin
• Kullanıcı başına hız limiti ekleyin

---

Yapay zeka ajanlarınız artık kalıcı belleğe sahip. Dünü hatırlıyorlar. Kararları geri çağırıyorlar. Kopyala-yapıştır yapmadan bağlamı devrediyorlar.

Artık "Önceki oturumlardan bağlamım yok." yok. Artık yeniden açıklama yok. Artık zaman kaybı yok.

MCP belleğinin gücü budur: ajanlarınıza ortak bir not defteri verin ve çok günlük projelerde gerçekten kullanışlı hale geldiklerini izleyin.

Sıkça Sorulan Sorular

MCP belleği nedir?

MCP belleği, yapay zeka ajanlarının oturumlar arasında bilgi depolamasını ve almasını sağlayan bir protokol uygulamasıdır. Ajanların tek konuşma ötesinde bağlamı kalıcı kılan ortak bir not defteri gibi davranır.

Claude Code için kalıcı bellek nasıl kurarım?

Bir MCP bellek sunucusu kurun, ardından sunucu komutu ve yolunu ~/.claude/settings.json dosyasına ekleyin. Claude Code'u yeniden başlatın ve bellek araçları (remember, recall, search, rollback) kullanılabilir olacaktır.

Hangi yapay zeka ajanları MCP belleğini destekler?

MCP uyumlu istemcilerde (Claude Code, Cursor, Windsurf) çalışan herhangi bir ajan bellek araçlarını kullanabilir. Ajan dosyalarını değiştirmenize gerek yok, sadece istemlerinize bellek talimatları ekleyin.

Ajan devirleri için en iyi bellek kalıpları nelerdir?

Bir sonraki ajan için bağlam bırakmak amacıyla remember'ı ["devir", "proje-adı"] gibi etiketlerle kullanın. Tamamlanan işleri, bekleyen öğeleri ve bilinen sorunları dahil edin. Alan ajan, recall(query="devir") çağrısı yaparak bunu alır.

MCP sunucuları ne kadar bellek depolayabilir?

Uygulamaya bağlıdır. Referans sunucu, süresiz olarak büyüyen bir JSON dosyası kullanır. Üretim sunucuları, büyük ölçek için sona erme politikaları, otomatik arşivleme veya bir veritabanı arka ucu eklemelidir.

Ekipler merkezi bir bellek sunucusunu paylaşabilir mi?

Evet. Bellek sunucusunu paylaşılan bir makinede veya bulutta çalıştırın, tüm ekip üyelerinin istemcilerini ona bağlayın ve düzenli geri alma için anıları projeye ve geliştiriciye göre etiketleyin.

Bellek geri çağırma çok fazla sonuç döndürürse ne olur?

Anıları saklarken daha spesifik etiketler ekleyin. Geri çağırma sorgularında ajan adına göre filtreleyin. Tırnak içinde tam ifadeler kullanın. Daha akıllı geri alma için gömme ile anlamsal arama eklemeyi değerlendirin.