feat(blog): Beyond Basic RAG with MCP and Graphiti

.github/workflows/integration.yml

@@ -8,15 +8,15 @@ jobs:
     name: Install Dependency
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
         with:
           ref: ${{ github.event.pull_request.head.sha }}
       - name: Use Node.js 18.x
-        uses: actions/setup-node@v1
+        uses: actions/setup-node@v4
         with:
           node-version: 18.x
       - name: Cache node modules
-        uses: actions/cache@v1
+        uses: actions/cache@v4
         with:
           path: node_modules
           key: node_modules-${{ github.event.pull_request.head.sha }}
@@ -33,11 +33,11 @@ jobs:
     needs: install
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
         with:
           ref: ${{ github.event.pull_request.head.sha }}
       - name: Load node_modules
-        uses: actions/cache@v1
+        uses: actions/cache@v4
         with:
           path: node_modules
           key: node_modules-${{ github.event.pull_request.head.sha }}
@@ -50,11 +50,11 @@ jobs:
     needs: install
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
         with:
           ref: ${{ github.event.pull_request.head.sha }}
       - name: Load node_modules
-        uses: actions/cache@v1
+        uses: actions/cache@v4
         with:
           path: node_modules
           key: node_modules-${{ github.event.pull_request.head.sha }}

src/contents/posts/en/beyond-basic-rag-mcp-graphiti.mdx

@@ -0,0 +1,58 @@
+---
+title: "Beyond Basic RAG: Building Autonomous AI Agents with MCP and Graphiti"
+slug: {
+  en: "beyond-basic-rag-mcp-graphiti",
+  id: "rag-ke-agen-ai-mcp-graphiti"
+}
+date: 2026-02-24
+description: "Why traditional RAG is no longer enough and how to build autonomous agents with long-term memory using Model Context Protocol (MCP) and Graphiti."
+keywords: "RAG, AI Agents, MCP, Graphiti, Neo4j, GraphRAG, Long-term Memory"
+tags: ["ai", "rag", "mcp", "graphiti"]
+image: "/media/blog/beyond-basic-rag-mcp-graphiti/banner.png"
+---
+
+Traditional RAG (Retrieval-Augmented Generation) has served us well, but as we move towards truly autonomous AI agents, the "stateless" nature of basic vector search is becoming a bottleneck. 
+
+If you've been following my recent experiments with **Nouva**, you know I've been pushing the boundaries of what a personal AI assistant can do. The secret sauce? Moving beyond simple document retrieval into a structured, evolving memory graph.
+
+### The Problem with Basic RAG
+
+Basic RAG is like a librarian who can find any book you ask for but forgets who you are the moment you leave the library. It's great for facts, but terrible for *contextual continuity*.
+
+1. **Context Fragmentation**: Vector databases are good at finding similar snippets, but they often lose the "big picture" or the relationships between different entities.
+2. **Static Knowledge**: Updating a vector index is often a batch process, making it hard for agents to learn in real-time.
+3. **No Agency**: Simple RAG is reactive. It doesn't know *how* to use the information it finds to perform complex tasks.
+
+### Enter Model Context Protocol (MCP)
+
+The [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) is a game-changer. It provides a standardized way for AI models to connect to external data sources and tools.
+
+Instead of hard-coding integrations, MCP allows us to create a plug-and-play ecosystem where an agent can:
+- Query a database.
+- Read a local file system.
+- Interact with specialized APIs (like Neo4j or Slack).
+
+This turns the AI from a chatbot into an **operator**.
+
+### Graphiti: The Living Memory Graph
+
+To solve the memory problem, I've been using **Graphiti**. Unlike a flat vector store, Graphiti builds a dynamic knowledge graph (often backed by Neo4j) that evolves as the agent interacts with the world.
+
+When the agent learns something new, it doesn't just store a string of text; it creates nodes and edges. For example: `[Gading] -> (LIKES) -> [Clean Code]`.
+
+This structure allows for:
+- **Relational Reasoning**: The agent can traverse the graph to find connections you didn't explicitly mention.
+- **Temporal Awareness**: Understanding when events happened and how they relate chronologically.
+- **Dynamic Updates**: Real-time memory injection without re-indexing the entire corpus.
+
+### Why This Matters for 2026
+
+We are shifting from "AI as a tool" to "AI as a partner." A partner needs to remember your preferences, your infrastructure (like my Proxmox setup), and even your family's needs (like reminders for Kak Rina).
+
+By combining **MCP** for tool execution and **Graphiti** for structured long-term memory, we are building agents that don't just answer questions—they anticipate needs and execute complex workflows autonomously.
+
+### Closing Thoughts
+
+If you're still just building "Chat with your PDF" apps, it's time to level up. The future belongs to agents that can think, remember, and act.
+
+Stay tuned as I dive deeper into the technical implementation of this stack in the coming weeks.

src/contents/posts/id/rag-ke-agen-ai-mcp-graphiti.mdx

@@ -0,0 +1,58 @@
+---
+title: "Lebih dari Sekadar RAG: Membangun Agen AI Otonom dengan MCP dan Graphiti"
+slug: {
+  en: "beyond-basic-rag-mcp-graphiti",
+  id: "rag-ke-agen-ai-mcp-graphiti"
+}
+date: 2026-02-24
+description: "Kenapa RAG tradisional mulai terasa kurang dan bagaimana cara membangun agen otonom dengan memori jangka panjang menggunakan Model Context Protocol (MCP) dan Graphiti."
+keywords: "RAG, AI Agents, MCP, Graphiti, Neo4j, GraphRAG, Memori Jangka Panjang"
+tags: ["ai", "rag", "mcp", "graphiti"]
+image: "/media/blog/beyond-basic-rag-mcp-graphiti/banner.png"
+---
+
+RAG (Retrieval-Augmented Generation) tradisional udah ngebantu kita banyak hal, tapi seiring berjalannya waktu menuju agen AI yang bener-bener otonom, sifat "lupa ingatan" (stateless) dari vector search mulai jadi hambatan.
+
+Kalau lu ngikutin eksperimen terbaru gue bareng **Nouva**, lu pasti tau gue lagi nyoba nembus batas kemampuan asisten AI personal. Rahasianya? Pindah dari sekadar ambil dokumen ke arah graf memori yang terstruktur dan terus berkembang.
+
+### Masalah dengan RAG Biasa
+
+RAG biasa itu kayak pustakawan yang jago nyari buku apa pun yang lu minta, tapi langsung lupa siapa lu begitu lu keluar dari perpustakaan. Oke banget buat nyari fakta, tapi ampas buat *contextual continuity*.
+
+1. **Fragmentasi Konteks**: Vector database jago nyari potongan teks yang mirip, tapi sering kehilangan "gambaran besar" atau hubungan antar entitas.
+2. **Pengetahuan Statis**: Update index vector itu biasanya proses batch, jadi susah buat agen buat belajar secara *real-time*.
+3. **Gak Punya Agency**: RAG biasa itu reaktif. Dia gak tau *gimana* cara pakai informasi yang dia temuin buat ngerjain tugas yang kompleks.
+
+### Mengenal Model Context Protocol (MCP)
+
+[Model Context Protocol (MCP)](https://modelcontextprotocol.io/) itu bener-bener pengubah permainan (*game-changer*). Protokol ini nyediain cara standar buat model AI terhubung ke sumber data eksternal dan tools.
+
+Daripada kita bikin integrasi manual satu-satu (hard-coding), MCP bikin ekosistem yang plug-and-play di mana agen bisa:
+- Query database.
+- Baca file system lokal.
+- Interaksi sama API khusus (kayak Neo4j atau Slack).
+
+Ini ngerubah AI dari sekadar chatbot jadi seorang **operator**.
+
+### Graphiti: Graf Memori yang "Hidup"
+
+Buat nyelesein masalah memori, gue pakai **Graphiti**. Beda sama vector store yang datar, Graphiti ngebangun graf pengetahuan dinamis (biasanya pakai Neo4j) yang berevolusi tiap kali agen berinteraksi.
+
+Pas agen belajar hal baru, dia gak cuma nyimpen teks; dia bikin "node" dan "edge". Contohnya: `[Gading] -> (SUKA) -> [Clean Code]`.
+
+Struktur ini memungkinkan:
+- **Relational Reasoning**: Agen bisa nelusuri graf buat nemuin koneksi yang gak lu sebutin secara eksplisit.
+- **Temporal Awareness**: Ngerti kapan suatu kejadian terjadi dan hubungannya secara kronologis.
+- **Dynamic Updates**: Suntikan memori real-time tanpa harus re-index seluruh data.
+
+### Kenapa Ini Penting di 2026?
+
+Kita lagi geser dari "AI sebagai alat" ke "AI sebagai partner". Seorang partner butuh inget preferensi lu, infrastruktur lu (kayak setup Proxmox gue), sampai kebutuhan keluarga (kayak reminder buat Kak Rina).
+
+Dengan gabungin **MCP** buat eksekusi tools dan **Graphiti** buat memori jangka panjang terstruktur, kita lagi bangun agen yang gak cuma jawab pertanyaan—tapi mengantisipasi kebutuhan dan jalanin workflow kompleks secara otonom.
+
+### Penutup
+
+Kalau lu masih cuma bikin aplikasi "Chat with your PDF", udah saatnya naik kelas. Masa depan itu milik agen yang bisa mikir, inget, dan bertindak.
+
+Pantau terus karena gue bakal bahas lebih dalem soal implementasi teknis stack ini di minggu-minggu depan.