Apa itu OpenViking? Panduan Lengkap dan Fitur Unggulan

TL;DR

OpenViking adalah basis data konteks sumber terbuka untuk agen AI yang menggantikan penyimpanan vektor datar dengan paradigma sistem file. Ia mengatur konteks (memori, sumber daya, keterampilan) di bawah URI viking:// dengan tiga lapisan: L0 (~100 token), L1 (~2k token), L2 (konten penuh). Tolok ukur menunjukkan pengurangan biaya token sebesar 91% dan penyelesaian tugas 43% lebih baik dibandingkan RAG tradisional.

Pendahuluan

Agen AI Anda terus melupakan sesuatu. Ia menanyakan *endpoint* API yang sama dua kali. Ia mengabaikan preferensi lingkungan *staging* Anda. Ia lupa tes mana yang lolos kemarin.

Ini adalah kenyataan dalam membangun agen saat ini. Sebagian besar tim menambal *pipeline* RAG, basis data vektor, dan sistem memori kustom. Hasilnya: konteks yang terfragmentasi, biaya token yang membengkak, dan pengambilan yang gagal secara diam-diam.

Data mendukung hal ini. Dalam tes *benchmark* menggunakan dataset LoCoMo10, sistem RAG tradisional hanya mencapai tingkat penyelesaian tugas 35-44% sambil menghabiskan 24-51 juta token masukan.

OpenViking mengambil pendekatan yang berbeda. Dibuat oleh tim OpenViking ByteDance, ia menggantikan penyimpanan vektor datar dengan paradigma sistem file. Semua konteks berada di bawah URI viking:// dengan pemuatan hierarkis L0/L1/L2. Hasilnya: 52% penyelesaian tugas dengan 91% lebih sedikit token.

Dalam panduan ini, Anda akan belajar bagaimana OpenViking memecahkan fragmentasi konteks, melihat model L0/L1/L2 beraksi, dan menerapkan server pertama Anda dalam 15 menit.

Masalah Konteks Agen

Agen AI menghadapi tantangan konteks yang tidak pernah ditangani oleh aplikasi tradisional.

Pertimbangkan agen yang membantu pengembang menguji API. Selama seminggu, agen perlu melacak:

• Preferensi pengguna ("lingkungan *staging*", "*curl* daripada Python")
• Konteks proyek (*endpoint*, metode otentikasi, hasil tes sebelumnya)
• Pola alat (*endpoint* mana yang gagal, kesalahan skema umum)
• Riwayat tugas (apa yang diuji, *bug* mana yang muncul)

RAG tradisional menyimpan ini sebagai potongan datar dalam basis data vektor. Mengkuerinya, Anda mendapatkan fragmen serupa top-K tanpa struktur, tanpa hierarki, dan tanpa visibilitas tentang apa yang terlewat.

Lima Tantangan Utama

OpenViking mengidentifikasi lima masalah inti dalam manajemen konteks agen:

Ini merepresentasikan pergeseran dari "simpan semuanya, ambil secara samar" menjadi "strukturkan semuanya, ambil secara tepat."

Apa Itu OpenViking?

OpenViking adalah basis data konteks sumber terbuka untuk agen AI, dibuat oleh tim OpenViking ByteDance di bawah lisensi Apache 2.0.

Ia menyatukan semua konteks ke dalam sistem file virtual. Memori, sumber daya, dan keterampilan dipetakan ke direktori di bawah viking://, masing-masing dengan URI unik.

viking://
├── resources/              # Pengetahuan Eksternal: dokumen, kode, halaman web
│   ├── my_project/
│   │   ├── docs/
│   │   │   ├── api/
│   │   │   └── tutorials/
│   │   └── src/
│   └── ...
├── user/                   # Spesifik Pengguna: preferensi, kebiasaan
│   └── memories/
│       ├── preferences/
│       │   ├── writing_style
│       │   └── coding_habits
│       └── ...
└── agent/                  # Kemampuan Agen: keterampilan, memori tugas
    ├── skills/
    │   ├── search_code
    │   ├── analyze_data
    │   └── ...
    ├── memories/
    └── instructions/

Agen mendapatkan kemampuan manipulasi konteks secara langsung:

• Navigasi direktori dengan ls viking://resources/my_project/docs/
• Cari secara semantik dengan find "metode otentikasi"
• Baca konten lengkap dengan read viking://resources/docs/auth.md
• Dapatkan ringkasan cepat dengan abstract viking://resources/docs/

Anggaplah ini sebagai perbedaan antara mencari seluruh *hard drive* Anda dan mengetahui dengan tepat direktori mana yang menyimpan file tersebut.

Fitur Utama 1: Paradigma Manajemen Sistem File

Paradigma sistem file memecahkan fragmentasi konteks dengan menyatukan semua jenis konteks di bawah satu model.

Tiga Jenis Konteks

Setiap jenis berada di direktorinya sendiri:

• viking://resources/: Manual produk, repositori kode, dokumentasi
• viking://user/memories/: Preferensi pengguna, memori entitas, peristiwa
• viking://agent/skills/: Definisi alat, konfigurasi MCP
• viking://agent/memories/: Pola yang dipelajari, studi kasus

API Mirip Unix

OpenViking menyediakan operasi baris perintah yang familiar:

from openviking import OpenViking

client = OpenViking(path="./data")

# Pencarian semantik di semua jenis konteks
results = client.find("otentikasi pengguna")

# Daftar isi direktori
contents = client.ls("viking://resources/")

# Baca konten lengkap
doc = client.read("viking://resources/docs/auth.md")

# Dapatkan ringkasan cepat (lapisan L0)
abstract = client.abstract("viking://resources/docs/")

# Dapatkan gambaran umum rinci (lapisan L1)
overview = client.overview("viking://resources/docs/")

API bekerja melalui SDK Python atau server HTTP, kompatibel dengan kerangka kerja agen apa pun.

Fitur Utama 2: Pemuatan Konteks Hierarkis L0/L1/L2

Memasukkan konteks besar ke dalam *prompt* itu mahal dan rawan kesalahan. OpenViking secara otomatis memproses semua konteks menjadi tiga lapisan hierarkis:

Cara Kerja

Saat Anda menambahkan sumber daya (seperti file dokumentasi PDF), OpenViking:

1. Menguraikan dokumen menjadi teks (belum ada panggilan LLM)
2. Membangun struktur pohon direktori di penyimpanan AGFS
3. Mengantrekan pemrosesan semantik secara asinkron
4. Menghasilkan abstrak L0 dan ikhtisar L1 secara *bottom-up*

Hasilnya adalah struktur hierarkis:

viking://resources/my_project/
├── .abstract.md               # L0: "Dokumentasi API yang mencakup otentikasi, endpoint, batas laju"
├── .overview.md               # L1: Ringkasan rinci dengan navigasi bagian
├── docs/
│   ├── .abstract.md          # Setiap direktori memiliki L0/L1
│   ├── .overview.md
│   ├── auth.md               # L2: Konten penuh
│   ├── endpoints.md
│   └── rate-limits.md
└── src/
    └── ...

Dampak Anggaran Token

Hierarki ini memungkinkan penghematan biaya yang signifikan:

# RAG Tradisional: Muat semua konten
full_docs = retrieve_all("otentikasi")  # 50k token

# OpenViking: Mulai dengan L1, muat L2 hanya jika diperlukan
overview = client.overview("viking://resources/docs/auth/")  # 2k token

if needs_more_detail(overview):
    content = client.read("viking://resources/docs/auth/oauth.md")  # Muat L2 spesifik

Dalam tes *benchmark*, pendekatan ini mengurangi biaya token masukan sebesar 91% dibandingkan RAG tradisional sambil meningkatkan tingkat penyelesaian tugas sebesar 43%.

Fitur Utama 3: Pengambilan Rekursif Direktori

Pencarian vektor tunggal kesulitan dengan kueri kompleks. OpenViking mengimplementasikan strategi pengambilan rekursif direktori:

Proses Lima Langkah

1. Analisis Intensi
   ↓
2. Penempatan Awal (temukan direktori skor tinggi)
   ↓
3. Eksplorasi yang Disempurnakan (cari di dalam direktori)
   ↓
4. Penelusuran Rekursif (masuk ke subdirektori)
   ↓
5. Agregasi Hasil (kembalikan konteks yang diberi peringkat)

Langkah 1: Analisis Intensi

Kueri "bagaimana cara mengautentikasi pengguna?" dianalisis untuk mengidentifikasi:

• Jenis intensi: pertanyaan prosedural cara melakukan
• Entitas kunci: "autentikasi", "pengguna"
• Konten yang diharapkan: panduan autentikasi, alur OAuth

Langkah 2: Penempatan Awal

Pencarian vektor dengan cepat menemukan direktori dengan skor tinggi:

• viking://resources/docs/auth/ (skor: 0.92)
• viking://resources/docs/security/ (skor: 0.78)

Langkah 3: Eksplorasi yang Disempurnakan

Dalam direktori teratas, pencarian sekunder menemukan file spesifik:

• viking://resources/docs/auth/oauth.md (skor: 0.95)
• viking://resources/docs/auth/jwt.md (skor: 0.88)

Langkah 4: Penelusuran Rekursif

Jika subdirektori ada (seperti auth/providers/), proses berulang secara rekursif.

Langkah 5: Agregasi Hasil

Hasil akhir diagregasi dan diberi peringkat berdasarkan relevansi, dengan jejak pengambilan yang dipertahankan.

Strategi "kunci direktori terlebih dahulu, lalu jelajahi konten" ini meningkatkan akurasi pengambilan dengan memahami konteks informasi penuh, bukan hanya potongan terisolasi.

Fitur Utama 4: Jejak Pengambilan yang Divisualisasikan

RAG tradisional adalah kotak hitam. Ketika pengambilan gagal, Anda tidak bisa tahu apakah itu masalah kesamaan vektor, masalah *chunking*, atau data yang hilang.

Struktur sistem file OpenViking membuat pengambilan dapat diamati:

Jejak Pengambilan untuk kueri: "penyegaran token OAuth"

├── viking://resources/docs/
│   ├── [SKOR: 0.45] .abstract.md: dilewati (relevansi rendah)
│   └── [SKOR: 0.89] auth/: terpilih (relevansi tinggi)
│       ├── [SKOR: 0.92] oauth.md: DIKEMBALIKAN
│       ├── [SKOR: 0.34] jwt.md: dilewati
│       └── [SKOR: 0.78] providers/
│           └── [SKOR: 0.85] google.md: DIKEMBALIKAN

Jejak ini menunjukkan:

• Direktori mana yang dikunjungi
• Mengapa file tertentu dipilih atau dilewati
• Jalur persis yang diambil oleh pengambilan

Untuk *debugging*, ini sangat berharga. Anda bisa melihat apakah agen melewatkan konteks karena berada di direktori yang salah, memiliki abstrak L0 yang buruk, atau jatuh di bawah ambang batas skor.

Fitur Utama 5: Manajemen Sesi Otomatis

OpenViking memiliki loop iterasi mandiri memori yang terpasang. Di akhir setiap sesi, sistem dapat mengekstrak memori dan memperbarui pengetahuan agen secara otomatis.

Enam Kategori Memori

Cara Kerja Ekstraksi Memori

# Mulai sesi
session = client.session()

# Tambahkan pesan (giliran percakapan)
await session.add_message("user", [{"type": "text", "text": "Saya lebih suka mode gelap di UI"}])
await session.add_message("assistant", [{"type": "text", "text": "Baik. Saya akan menggunakan mode gelap untuk semua tangkapan layar di masa mendatang."}])

# Rekam penggunaan alat
await session.add_usage({
    "tool": "screenshot",
    "parameters": {"theme": "dark"},
    "result": "success"
})

# Komit sesi: memicu ekstraksi memori
await session.commit()

Saat dikomit, OpenViking:

1. Mengompres sesi (menyimpan N giliran terbaru, mengarsipkan yang lebih lama)
2. Mengekstrak memori menggunakan analisis LLM
3. Memperbarui direktori memori yang sesuai
4. Menghasilkan L0/L1 untuk konten memori baru

Ini membuat agen lebih pintar dengan penggunaan: mereka belajar preferensi pengguna, mengumpulkan pengalaman tugas, dan meningkatkan pengambilan keputusan seiring waktu.

Gambaran Umum Arsitektur

Arsitektur sistem OpenViking memisahkan kekhawatiran di beberapa lapisan:

Penyimpanan Dua Lapisan

OpenViking memisahkan konten dari indeks:

Pemisahan ini memastikan:

• Semua pembacaan konten berasal dari satu sumber (AGFS)
• Indeks vektor hanya menyimpan referensi ringan
• Tidak ada duplikasi *blob* teks besar dalam penyimpanan vektor

Mulai Cepat: Terapkan Server OpenViking Pertama Anda

Prasyarat

• Python: 3.10 atau lebih tinggi
• Go: 1.22+ (untuk komponen AGFS)
• C++ Compiler: GCC 9+ atau Clang 11+
• OS: Linux, macOS, atau Windows

Langkah 1: Instal OpenViking

pip install openviking --upgrade --force-reinstall

Secara opsional instal CLI Rust untuk akses terminal:

curl -fsSL https://raw.githubusercontent.com/volcengine/OpenViking/main/crates/ov_cli/install.sh | bash

Langkah 2: Konfigurasi Model

OpenViking membutuhkan dua kemampuan model:

• Model VLM: Untuk pemahaman gambar dan konten
• Model *Embedding*: Untuk vektorisasi dan pencarian semantik

Buat ~/.openviking/ov.conf:

{
  "storage": {
    "workspace": "/home/nama-anda/openviking_workspace"
  },
  "log": {
    "level": "INFO",
    "output": "stdout"
  },
  "embedding": {
    "dense": {
      "api_base": "https://api.openai.com/v1",
      "api_key": "kunci-api-openai-anda",
      "provider": "openai",
      "dimension": 3072,
      "model": "text-embedding-3-large"
    },
    "max_concurrent": 10
  },
  "vlm": {
    "api_base": "https://api.openai.com/v1",
    "api_key": "kunci-api-openai-anda",
    "provider": "openai",
    "model": "gpt-4o",
    "max_concurrent": 100
  }
}

Penyedia yang Didukung:

Dukungan LiteLLM berarti Anda dapat menggunakan model Anthropic, Google, model Ollama lokal, atau *endpoint* yang kompatibel dengan OpenAI.

Langkah 3: Mulai Server

openviking-server

Atau jalankan di latar belakang:

nohup openviking-server > /data/log/openviking.log 2>&1 &

Langkah 4: Tambahkan Sumber Daya Pertama Anda

# Menggunakan CLI Rust
ov add-resource https://docs.example.com/api-guide.pdf

# Atau menggunakan SDK Python
from openviking import OpenViking

client = OpenViking(path="./data")
client.add_resource("https://docs.example.com/api-guide.pdf")

Langkah 5: Cari dan Ambil

# Tunggu pemrosesan semantik, lalu cari
ov find "metode otentikasi"

# Daftar isi direktori
ov ls viking://resources/

# Lihat pohon direktori
ov tree viking://resources/docs -L 2

# Grep untuk konten spesifik
ov grep "OAuth" --uri viking://resources/docs/

Langkah 6: Aktifkan VikingBot (Opsional)

VikingBot adalah kerangka kerja agen AI yang dibangun di atas OpenViking:

pip install "openviking[bot]"

# Mulai server dengan bot diaktifkan
openviking-server --with-bot

# Di terminal lain, mulai obrolan interaktif
ov chat

Tolok Ukur Kinerja

OpenViking diuji terhadap RAG tradisional (LanceDB) dan sistem memori asli menggunakan dataset LoCoMo10 (1.540 kasus dialog jarak jauh).

Tingkat Penyelesaian Tugas

Temuan Utama

• Peningkatan 43% dibandingkan memori asli dengan pengurangan token 91%
• Peningkatan 17% dibandingkan LanceDB dengan pengurangan token 92%
• Pengambilan hierarkis OpenViking menemukan konteks yang lebih relevan sambil mengonsumsi lebih sedikit token

Hasil ini berasal dari integrasi OpenViking sebagai *plugin* dengan OpenClaw, asisten pengkodean AI sumber terbuka. Dataset uji didasarkan pada dialog jarak jauh di mana retensi memori sangat penting.

Mengintegrasikan OpenViking dengan Apidog

Pengguna Apidog yang membangun agen AI untuk pengujian API dapat memanfaatkan OpenViking untuk menjaga konteks percakapan, menyimpan dokumentasi API, dan mengingat preferensi pengguna di seluruh sesi.

Langkah 1: Siapkan Server OpenViking

Ikuti panduan mulai cepat di atas untuk menerapkan OpenViking dengan model VLM dan *embedding* pilihan Anda.

Langkah 2: Impor Dokumentasi API Apidog

# Tambahkan dokumentasi proyek Apidog Anda sebagai sumber daya
ov add-resource https://docs.apidog.com/overview
ov add-resource https://docs.apidog.com/api-testing

Ini mengimpor dokumentasi Apidog ke viking://resources/ dengan pemrosesan L0/L1/L2 otomatis.

Langkah 3: Simpan Preferensi Pengguna

from openviking import OpenViking

client = OpenViking(path="./apidog-agent-data")
session = client.session()

# Rekam preferensi lingkungan default pengguna
await session.add_message("user", [{
    "type": "text",
    "text": "Selalu gunakan lingkungan staging untuk tes API"
}])
await session.commit()  # Mengekstrak memori preferensi secara otomatis

Langkah 4: Kueri Konteks Selama Pengujian

# Temukan endpoint API yang relevan sebelum menjalankan tes
results = client.find("endpoint otentikasi")
for ctx in results.resources:
    print(f"Ditemukan: {ctx.uri}")

# Ambil preferensi lingkungan pengguna
prefs = client.find("preferensi lingkungan staging", target_uri="viking://user/memories/")

Langkah 5: Hubungkan ke Kerangka Kerja Agen Anda

OpenViking mengekspos SDK Python dan API HTTP:

# SDK Python
from openviking import OpenViking
client = OpenViking(path="./data")

# Atau API HTTP
import httpx
response = httpx.post(
    "http://localhost:1933/api/v1/search/find",
    json={"query": "endpoint otentikasi"},
    headers={"X-API-Key": "kunci-api-anda"}
)

Teknik Lanjutan & Praktik Terbaik

Tips Pro untuk Penerapan Produksi

1. Hangatkan Konteks yang Sering Diakses Sebelumnya

Muat dokumentasi penting ke L0/L1 selama jam-jam non-puncak untuk mengurangi latensi selama operasi agen.

# Picu pemrosesan semantik segera
ov add-resource https://docs.example.com --wait

2. Terapkan Kedaluwarsa Konteks

Siapkan pembersihan otomatis untuk data sesi yang usang:

# Arsipkan sesi yang lebih tua dari 7 hari
await session.archive(max_age_days=7)

3. Pantau Kesehatan Indeks Vektor

Lacak ukuran indeks dan latensi kueri:

ov debug stats

Kesalahan Umum yang Harus Dihindari

1. Memuat konten L2 terlalu dini: Selalu mulai dengan L0/L1 untuk menghemat token
2. Melewatkan komit sesi: Ekstraksi memori hanya terjadi pada komit
3. Memuat direktori tunggal secara berlebihan: Pisahkan sumber daya besar menjadi subdirektori berdasarkan topik
4. Mengabaikan jejak pengambilan: Gunakan jejak visual untuk mendebug hasil yang buruk

Optimasi Kinerja

Praktik Terbaik Keamanan

• Simpan kunci API di variabel lingkungan atau manajer rahasia (jangan pernah di file konfigurasi)
• Aktifkan HTTPS untuk semua penerapan server HTTP
• Terapkan pembatasan laju pada *endpoint* publik
• Gunakan kunci API terpisah untuk pengembangan dan produksi

Kasus Penggunaan Dunia Nyata

1. Asisten Pengkodean AI

Sebuah tim pengembangan mengintegrasikan OpenViking dengan asisten pengkodean internal mereka. Agen sekarang:

• Menavigasi struktur proyek melalui viking://resources/my_project/src/
• Mengingat preferensi pengkodean pengguna (konvensi penamaan, kerangka kerja pengujian)
• Mengambil dokumentasi API yang relevan selama pembuatan kode

Hasil: Pengurangan 67% dalam perilaku agen yang "pelupa", penghematan biaya token 43%.

2. Agen Dukungan Pelanggan

Sebuah perusahaan SaaS menerapkan OpenViking untuk *chatbot* dukungan mereka:

• Dokumentasi produk disimpan di viking://resources/product/
• Riwayat percakapan pelanggan di viking://user/memories/past_issues/
• Buku pedoman dukungan sebagai keterampilan di viking://agent/skills/

Hasil: Resolusi kontak pertama meningkat dari 52% menjadi 71%.

3. Asisten Penelitian

Sebuah laboratorium penelitian menggunakan OpenViking untuk mengatur makalah dan catatan:

• Makalah dikategorikan berdasarkan topik (viking://resources/papers/nlp/)
• Metodologi penelitian disimpan sebagai keterampilan
• Ekstraksi otomatis temuan kunci ke dalam memori

Hasil: Peneliti menemukan makalah yang relevan 3x lebih cepat dengan pencarian semantik.

Alternatif & Perbandingan

OpenViking bukan satu-satunya solusi manajemen konteks. Berikut adalah perbandingannya dengan alternatif:

OpenViking vs. Basis Data Vektor Tradisional

OpenViking vs. Memori LangChain

Kapan Harus Mempertimbangkan Alternatif

Gunakan basis data vektor tradisional jika:

• Anda membutuhkan latensi pengambilan di bawah 100ms
• Kasus penggunaan Anda adalah pencarian kata kunci sederhana
• Anda sudah memiliki *pipeline* RAG yang berfungsi tanpa masalah

Gunakan OpenViking jika:

• Anda membangun percakapan agen yang berjalan lama
• Anda membutuhkan konteks multi-jenis (dokumen + preferensi + alat)
• Optimasi biaya token itu penting
• Anda ingin pengambilan yang dapat diamati, dapat di-*debug*

Perbandingan dengan RAG Tradisional

Penerapan Produksi

Untuk lingkungan produksi, jalankan OpenViking sebagai layanan HTTP *standalone*:

Infrastruktur yang Direkomendasikan

• Cloud: Volcengine ECS atau yang setara
• OS: veLinux atau Ubuntu 22.04+
• Penyimpanan: Volume yang didukung SSD untuk AGFS
• Jaringan: Koneksi latensi rendah ke API model

Pertimbangan Keamanan

• Simpan kunci API di variabel lingkungan atau manajer rahasia
• Aktifkan otentikasi untuk *endpoint* HTTP
• Gunakan HTTPS untuk semua komunikasi klien-server
• Terapkan pembatasan laju untuk mencegah penyalahgunaan

Pemantauan

OpenViking mendukung pencatatan dan metrik:

{
  "log": {
    "level": "INFO",
    "output": "file",
    "path": "/var/log/openviking/server.log"
  }
}

Pantau:

• Kedalaman antrean pemrosesan semantik
• Latensi pencarian vektor
• Operasi baca/tulis AGFS
• Tingkat keberhasilan ekstraksi memori

Keterbatasan dan Pertimbangan

Keterbatasan Saat Ini

• Berpusat pada Python: SDK utama adalah Python; bahasa lain membutuhkan integrasi HTTP
• Ketergantungan model: Membutuhkan model VLM eksternal dan *embedding* (tidak ada *inferensi* bawaan)
• Kurva pembelajaran: Paradigma sistem file berbeda dari DB vektor tradisional
• Tahap awal: Proyek dalam pengembangan aktif; API dapat berubah

Kapan Menggunakan OpenViking

Sangat cocok:

• Percakapan agen yang berjalan lama membutuhkan memori
• Konteks multi-jenis (dokumen + preferensi + alat)
• Kebutuhan akan pengambilan yang dapat diamati, dapat di-*debug*
• Optimasi biaya token itu penting

Pertimbangkan alternatif:

• Aplikasi tanya jawab sederhana satu kali
• Sudah memiliki *pipeline* RAG yang berfungsi tanpa masalah
• Membutuhkan latensi pengambilan di bawah 100ms (OpenViking menambah *overhead* pemrosesan)

Jalan ke Depan

OpenViking sedang dalam pengembangan awal (versi 0.1.x per awal 2025). *Roadmap* mencakup:

• Dukungan *multi-tenant*: *Workspace* terisolasi untuk tim
• Analitik lanjutan: Metrik kualitas pengambilan, *dashboard* penggunaan memori
• Ekosistem *plugin*: Integrasi bawaan dengan kerangka kerja agen populer
• Penerapan *Edge*: Mode ringan untuk aplikasi yang mengutamakan lokal
• Dukungan MCP yang ditingkatkan: Integrasi Protokol Konteks Model (MCP) asli

Tim di balik OpenViking secara aktif mencari kontributor komunitas. Proyek ini adalah sumber terbuka di bawah Apache 2.0, dengan dokumentasi tersedia.

Kesimpulan

OpenViking merepresentasikan pergeseran dalam cara agen AI mengelola konteks. Dengan mengatur informasi sebagai sistem file alih-alih potongan datar, ia memecahkan fragmentasi, pemborosan token, dan pengambilan kotak hitam yang mengganggu sistem RAG tradisional.

Poin-Poin Penting

• Paradigma sistem file menyatukan konteks: Semua memori, sumber daya, dan keterampilan di bawah URI viking://
• Pemuatan L0/L1/L2 mengurangi token sebesar 91%: Pemuatan progresif alih-alih membuang semuanya ke dalam *prompt*
• Pengambilan rekursif direktori meningkatkan akurasi: Kunci direktori skor tinggi terlebih dahulu, lalu jelajahi konten
• Jejak visual memungkinkan *debugging*: Lihat persis jalur yang diambil oleh pengambilan
• Manajemen sesi otomatis memungkinkan pembelajaran: Agen mengekstrak memori dari setiap percakapan