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.

“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.

button

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 olarak düşünün.

Dört araç MCP belleğini destekler:

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ı kullanıma sunan bir MCP sunucusuna ihtiyacınız var. Birkaç açık kaynaklı uygulama mevcuttur.

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

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

Seçenek B: Basit bir yerel sunucu çalıştırın

memory-server.js 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 => {
      const matchesQuery = m.content.toLowerCase().includes(query.toLowerCase()) ||
                          m.tags.some(t => t.toLowerCase().includes(query.toLowerCase()));
      const matchesAgent = !agent || m.agent === agent;
      return matchesQuery && matchesAgent;
    });
    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 çalıştırın:

node memory-server.js

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

Ajan dosyalarını değiştirmenize gerek yok. Bellek talimatlarını isteminize 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

Uygulamada ö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 MCP yapılandırmanıza ekleyin:

~/.claude/settings.json dosyasını düzenleyin:

{
  "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 olmalıdır.

Test edin:

"E-ticaret projesi için test belleği"ni depolamak için remember aracını kullanın
Tags: ["test", "ecommerce-api"]

"test" hakkındaki anıları bulmak için recall aracını kullanın

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

Projenizde .cursor/mcp.json oluşturun:

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

Test edin:

@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üğü

Teknik bir karar verdiğiniz her seferde, bunu 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, biri “Neden PostgreSQL?” diye sorduğunda:

recall(query="PostgreSQL MySQL karar")

Kalıp 2: Ajan Devirleri

Ajanları değiştirirken, bir devir notu bırakı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 şununla başlar:

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

Kalıp 3: Oturum Kontrol Noktaları

Her çalışma oturumunun 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"
})

Sonraki oturuma devam edin:

recall(query="checkpoint session-1")

Kalıp 4: Hata Takibi

Bir hata bulduğunuzda:

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"
})

Daha sonra hataları arayın:

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ına sahip olduğunu doğrulayın

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

Daha spesifik etiketler ekleyin
Ajan adına göre filtreleyin
Tırnak işaretleri 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 şemanıza son kullanma tarihleri 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şletin:

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şturun:

Ekibiniz genelinde merkezi 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çlarla entegre edin:

Git taahhütlerini otomatik olarak anı olarak kaydedin
Proje yönetimi (Jira, Linear) ile senkronize edin
Anıları belgelere 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 yapılandırmasının doğru yolu gösterdiğini onaylayın

Geri çağırma boş sonuçlar döndürüyor:

Sorgunun depolanan etiketlerle eşleştiğini doğrulayın (büyük/küçük harf duyarlı)
Daha geniş arama terimleri deneyin veya belirli etiketlerle search kullanın
Anıların gerçekten depolanıp depolanmadığını kontrol edin: cat ~/.mcp-memory/memories.json
Ajan adı filtresinin eşleştiğinden emin olun (agent parametresi kullanılıyorsa)

Bellek dosyası çok büyüyor:

30 günden eski anılar için otomatik arşivleme uygulayın
Belirli bir tarih aralığındaki anıları silen bir prune aracı ekleyin
Anıları projeye veya tarihe göre ayrı dosyalara bölün
Büyük ölçekli kullanım için JSON yerine bir veritabanı arka ucu (SQLite) 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 kodundaki sözdizimi hatalarını arayın
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ısı yaparken her zaman agent alanını dahil edin
Proje başına benzersiz etiketler kullanın: ["project-x", "backend", "auth"]
Bağlamı alırken geri çağırma işlemini ajan adına göre filtreleyin
Proje başına ayrı bellek dosyalarını düşünün

Bellek Sunucusu Güvenlik Hususları

API Anahtarı Depolama: Bellek sunucunuz hassas verileri (API anahtarları, parolalar) depoluyorsa, ş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ı için kimlik doğrulama ekleyin:

Bellek aracı çağrılarında API anahtarı isteyin
Kullanıcıya özel bellek ad alanları uygulayın
Denetim izleri için tüm bellek işlemlerini kaydedin
Kullanıcı başına istekleri hız sınırlayın

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.

button

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. Bunu, ajanların yazıp okuyabileceği, tek konuşmaların ötesinde bağlamı kalıcı kılan ortak bir not defteri olarak düşünün.

Claude Code için kalıcı bellek nasıl kurarım? Bir MCP bellek sunucusu kurun, ardından sunucu komutu ve yolu ile ~/.claude/settings.json dosyasına ekleyin. Claude Code'u yeniden başlatın ve bellek araçları (remember, recall, search, rollback) kullanılabilir hale gelir.

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çekli kullanım için sona erme politikaları, otomatik arşivleme veya veritabanı arka uçları eklemelidir.

Ekipler merkezi bir bellek sunucusunu paylaşabilir mi? Evet. Bellek sunucusunu paylaşılan bir makinede veya bulut örneğinde çalıştırın, tüm ekip üyelerinin istemcilerini ona bağlanacak şekilde yapılandırı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ınızda ajan adına göre filtreleyin. Tırnak işaretleri içinde tam ifadeler kullanın. Daha akıllı geri alma için gömme ile anlamsal arama uygulamayı düşünün.