OpenViking คืออะไร

สรุปสาระสำคัญ (TL;DR)

OpenViking คือฐานข้อมูลบริบทแบบโอเพนซอร์สสำหรับเอเจนต์ AI ซึ่งมาแทนที่การจัดเก็บเวกเตอร์แบบเรียบด้วยรูปแบบระบบไฟล์ โดยจะจัดระเบียบบริบท (ความทรงจำ, ทรัพยากร, ทักษะ) ภายใต้ URI viking:// โดยมีสามเลเยอร์: L0 (ประมาณ 100 โทเค็น), L1 (ประมาณ 2k โทเค็น), L2 (เนื้อหาเต็ม) ผลการทดสอบแสดงให้เห็นว่าลดต้นทุนโทเค็นได้ 91% และทำงานสำเร็จได้ดีขึ้น 43% เมื่อเทียบกับ RAG แบบดั้งเดิม

บทนำ

เอเจนต์ AI ของคุณมักจะลืมสิ่งต่าง ๆ มันขอปลายทาง API ตัวเดิมถึงสองครั้ง มันเพิกเฉยต่อการตั้งค่าสภาพแวดล้อมทดสอบของคุณ มันลืมว่าการทดสอบใดผ่านไปเมื่อวานนี้

นี่คือความเป็นจริงของการสร้างเอเจนต์ในปัจจุบัน ทีมส่วนใหญ่จะนำ RAG pipelines, ฐานข้อมูลเวกเตอร์ และระบบหน่วยความจำแบบกำหนดเองมารวมกัน ผลลัพธ์ที่ได้: บริบทที่กระจัดกระจาย, ค่าโทเค็นที่พุ่งสูงขึ้น, และการเรียกคืนข้อมูลที่ล้มเหลวอย่างเงียบ ๆ

ข้อมูลสนับสนุนสิ่งนี้ ในการทดสอบเกณฑ์มาตรฐานโดยใช้ชุดข้อมูล LoCoMo10 ระบบ RAG แบบดั้งเดิมทำอัตราการทำงานสำเร็จได้เพียง 35-44% ในขณะที่ใช้โทเค็นอินพุตไป 24-51 ล้านโทเค็น

OpenViking ใช้วิธีการที่แตกต่างออกไป สร้างโดยทีม OpenViking ของ ByteDance โดยมาแทนที่การจัดเก็บเวกเตอร์แบบเรียบด้วยรูปแบบระบบไฟล์ บริบททั้งหมดอยู่ภายใต้ URI viking:// พร้อมกับการโหลดแบบลำดับชั้น L0/L1/L2 ผลลัพธ์ที่ได้: ทำงานสำเร็จ 52% โดยใช้โทเค็นน้อยลง 91%

ในคู่มือนี้ คุณจะได้เรียนรู้วิธีที่ OpenViking แก้ปัญหาบริบทที่กระจัดกระจาย, เห็นโมเดล L0/L1/L2 ในการทำงานจริง และปรับใช้เซิร์ฟเวอร์แรกของคุณภายใน 15 นาที

ปัญหาบริบทของเอเจนต์

เอเจนต์ AI เผชิญกับความท้าทายด้านบริบทที่แอปพลิเคชันแบบดั้งเดิมไม่เคยเจอมาก่อน

ลองพิจารณาเอเจนต์ที่ช่วยนักพัฒนาทดสอบ API ในช่วงหนึ่งสัปดาห์ มันจำเป็นต้องติดตาม:

• การตั้งค่าของผู้ใช้ (“สภาพแวดล้อมทดสอบ”, “curl มากกว่า Python”)
• บริบทของโปรเจกต์ (ปลายทาง, วิธีการยืนยันตัวตน, ผลการทดสอบที่ผ่านมา)
• รูปแบบเครื่องมือ (ปลายทางใดบ้างที่ล้มเหลว, ข้อผิดพลาดของ Schema ทั่วไป)
• ประวัติงาน (ทดสอบอะไรไปบ้าง, พบข้อผิดพลาดใดบ้าง)

RAG แบบดั้งเดิมจัดเก็บสิ่งนี้เป็นส่วนย่อยแบบเรียบในฐานข้อมูลเวกเตอร์ เมื่อสอบถาม คุณจะได้ส่วนย่อยที่คล้ายกัน Top-K โดยไม่มีโครงสร้าง ไม่มีลำดับชั้น และไม่มีข้อมูลว่ามีอะไรที่ขาดหายไป

ความท้าทายหลักห้าประการ

OpenViking ระบุปัญหาหลักห้าประการในการจัดการบริบทของเอเจนต์:

สิ่งนี้แสดงถึงการเปลี่ยนแปลงจาก “จัดเก็บทุกสิ่ง, เรียกคืนอย่างคลุมเครือ” ไปสู่ “จัดโครงสร้างทุกสิ่ง, เรียกคืนอย่างแม่นยำ”

OpenViking คืออะไร?

OpenViking คือฐานข้อมูลบริบทแบบโอเพนซอร์สสำหรับเอเจนต์ AI ที่สร้างโดยทีม OpenViking ของ ByteDance ภายใต้ไลเซนส์ Apache 2.0

มันรวบรวมบริบททั้งหมดเข้าสู่ระบบไฟล์เสมือน ความทรงจำ, ทรัพยากร และทักษะจะถูกแมปไปยังไดเรกทอรีภายใต้ viking:// โดยแต่ละรายการมี URI ที่ไม่ซ้ำกัน

viking://
├── resources/              # External knowledge: docs, code, web pages
│   ├── my_project/
│   │   ├── docs/
│   │   │   ├── api/
│   │   │   └── tutorials/
│   │   └── src/
│   └── ...
├── user/                   # User-specific: preferences, habits
│   └── memories/
│       ├── preferences/
│       │   ├── writing_style
│       │   └── coding_habits
│       └── ...
└── agent/                  # Agent capabilities: skills, task memories
    ├── skills/
    │   ├── search_code
    │   ├── analyze_data
    │   └── ...
    ├── memories/
    └── instructions/

เอเจนต์จะได้รับความสามารถในการจัดการบริบทโดยตรง:

• นำทางไดเรกทอรีด้วย ls viking://resources/my_project/docs/
• ค้นหาเชิงความหมายด้วย find "authentication methods"
• อ่านเนื้อหาเต็มด้วย read viking://resources/docs/auth.md
• รับสรุปอย่างรวดเร็วด้วย abstract viking://resources/docs/

ลองนึกภาพความแตกต่างระหว่างการค้นหาฮาร์ดไดรฟ์ทั้งหมดของคุณ กับการรู้ว่าไฟล์นั้นอยู่ในไดเรกทอรีใด

คุณสมบัติหลัก 1: รูปแบบการจัดการระบบไฟล์

รูปแบบระบบไฟล์แก้ปัญหาบริบทที่กระจัดกระจายโดยการรวมประเภทบริบททั้งหมดภายใต้โมเดลเดียว

บริบทสามประเภท

แต่ละประเภทจะอยู่ในไดเรกทอรีของตัวเอง:

• viking://resources/: คู่มือผลิตภัณฑ์, ที่เก็บโค้ด, เอกสาร
• viking://user/memories/: การตั้งค่าของผู้ใช้, ความทรงจำของเอนทิตี, เหตุการณ์
• viking://agent/skills/: การกำหนดเครื่องมือ, การกำหนดค่า MCP
• viking://agent/memories/: รูปแบบที่เรียนรู้, กรณีศึกษา

API แบบ Unix

OpenViking มีการทำงานแบบบรรทัดคำสั่งที่คุ้นเคย:

from openviking import OpenViking

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

# Semantic search across all context types
results = client.find("user authentication")

# List directory contents
contents = client.ls("viking://resources/")

# Read full content
doc = client.read("viking://resources/docs/auth.md")

# Get quick summary (L0 layer)
abstract = client.abstract("viking://resources/docs/")

# Get detailed overview (L1 layer)
overview = client.overview("viking://resources/docs/")

API ทำงานผ่าน Python SDK หรือเซิร์ฟเวอร์ HTTP ซึ่งเข้ากันได้กับเฟรมเวิร์กเอเจนต์ใด ๆ

คุณสมบัติหลัก 2: การโหลดบริบทแบบลำดับชั้น L0/L1/L2

การอัดบริบทขนาดใหญ่เข้าไปในพรอมต์นั้นมีค่าใช้จ่ายสูงและมีแนวโน้มที่จะเกิดข้อผิดพลาด OpenViking จะประมวลผลบริบททั้งหมดเป็นสามเลเยอร์แบบลำดับชั้นโดยอัตโนมัติ:

วิธีการทำงาน

เมื่อคุณเพิ่มทรัพยากร (เช่น ไฟล์เอกสาร PDF) OpenViking จะ:

1. แยกวิเคราะห์เอกสารเป็นข้อความ (ยังไม่มีการเรียก LLM)
2. สร้างโครงสร้างต้นไม้ไดเรกทอรีในการจัดเก็บ AGFS
3. จัดคิวการประมวลผลเชิงความหมายแบบอะซิงโครนัส
4. สร้างบทคัดย่อ L0 และภาพรวม L1 จากล่างขึ้นบน

ผลลัพธ์คือโครงสร้างแบบลำดับชั้น:

viking://resources/my_project/
├── .abstract.md               # L0: "เอกสาร API ที่ครอบคลุมการยืนยันตัวตน, ปลายทาง, ข้อจำกัดอัตรา"
├── .overview.md               # L1: สรุปโดยละเอียดพร้อมการนำทางส่วน
├── docs/
│   ├── .abstract.md          # แต่ละไดเรกทอรีมี L0/L1
│   ├── .overview.md
│   ├── auth.md               # L2: เนื้อหาเต็ม
│   ├── endpoints.md
│   └── rate-limits.md
└── src/
    └── ...

ผลกระทบต่องบประมาณโทเค็น

ลำดับชั้นนี้ช่วยให้ประหยัดค่าใช้จ่ายได้อย่างมาก:

# RAG แบบดั้งเดิม: โหลดเนื้อหาทั้งหมด
full_docs = retrieve_all("authentication")  # 50k tokens

# OpenViking: เริ่มต้นด้วย L1, โหลด L2 เมื่อจำเป็นเท่านั้น
overview = client.overview("viking://resources/docs/auth/")  # 2k tokens

if needs_more_detail(overview):
    content = client.read("viking://resources/docs/auth/oauth.md")  # โหลด L2 ที่เฉพาะเจาะจง

ในการทดสอบเกณฑ์มาตรฐาน วิธีการนี้ลดต้นทุนโทเค็นอินพุตลง 91% เมื่อเทียบกับ RAG แบบดั้งเดิม ในขณะที่ปรับปรุงอัตราการทำงานสำเร็จขึ้น 43%

คุณสมบัติหลัก 3: การเรียกคืนข้อมูลแบบ Directory Recursive

การค้นหาเวกเตอร์เดี่ยวมีปัญหาในการจัดการกับคำค้นหาที่ซับซ้อน OpenViking ใช้ กลยุทธ์การเรียกคืนข้อมูลแบบ directory recursive:

กระบวนการห้าขั้นตอน

1. การวิเคราะห์เจตนา
   ↓
2. การวางตำแหน่งเริ่มต้น (ค้นหาไดเรกทอรีที่มีคะแนนสูง)
   ↓
3. การสำรวจที่ละเอียดขึ้น (ค้นหาภายในไดเรกทอรี)
   ↓
4. การลงลึกแบบวนซ้ำ (เจาะเข้าไปในไดเรกทอรีย่อย)
   ↓
5. การรวมผลลัพธ์ (คืนบริบทที่จัดอันดับ)

ขั้นตอนที่ 1: การวิเคราะห์เจตนา

คำถาม “ฉันจะยืนยันตัวตนผู้ใช้ได้อย่างไร” จะถูกวิเคราะห์เพื่อระบุ:

• ประเภทเจตนา: คำถามเชิงขั้นตอนการทำ
• เอนทิตีหลัก: “ยืนยันตัวตน”, “ผู้ใช้”
• เนื้อหาที่คาดหวัง: คู่มือการยืนยันตัวตน, OAuth flows

ขั้นตอนที่ 2: การวางตำแหน่งเริ่มต้น

การค้นหาเวกเตอร์จะระบุตำแหน่งไดเรกทอรีที่มีคะแนนสูงได้อย่างรวดเร็ว:

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

ขั้นตอนที่ 3: การสำรวจที่ละเอียดขึ้น

ภายในไดเรกทอรีอันดับต้น การค้นหารองจะค้นหาไฟล์ที่เฉพาะเจาะจง:

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

ขั้นตอนที่ 4: การลงลึกแบบวนซ้ำ

หากมีไดเรกทอรีย่อย (เช่น auth/providers/) กระบวนการจะทำซ้ำแบบวนซ้ำ

ขั้นตอนที่ 5: การรวมผลลัพธ์

ผลลัพธ์สุดท้ายจะถูกรวมและจัดอันดับตามความเกี่ยวข้อง พร้อมรักษาเส้นทางการเรียกคืนข้อมูลไว้

กลยุทธ์ “ล็อคไดเรกทอรีก่อน แล้วจึงสำรวจเนื้อหา” นี้ช่วยเพิ่มความแม่นยำในการเรียกคืนข้อมูลโดยการทำความเข้าใจบริบททั้งหมดของข้อมูล ไม่ใช่แค่ส่วนย่อยที่แยกออกมา

คุณสมบัติหลัก 4: การแสดงภาพเส้นทางการเรียกคืนข้อมูล

RAG แบบดั้งเดิมเป็นเหมือนกล่องดำ เมื่อการเรียกคืนข้อมูลล้มเหลว คุณไม่สามารถบอกได้ว่าเป็นปัญหาความคล้ายคลึงของเวกเตอร์, ปัญหาการแบ่งส่วน หรือข้อมูลที่ขาดหายไป

โครงสร้างระบบไฟล์ของ OpenViking ทำให้การเรียกคืนข้อมูล สามารถสังเกตได้:

เส้นทางการเรียกคืนข้อมูลสำหรับคำถาม: "OAuth token refresh"

├── viking://resources/docs/
│   ├── [คะแนน: 0.45] .abstract.md: ข้าม (ความเกี่ยวข้องต่ำ)
│   └── [คะแนน: 0.89] auth/: เลือก (ความเกี่ยวข้องสูง)
│       ├── [คะแนน: 0.92] oauth.md: ส่งคืน
│       ├── [คะแนน: 0.34] jwt.md: ข้าม
│       └── [คะแนน: 0.78] providers/
│           └── [คะแนน: 0.85] google.md: ส่งคืน

เส้นทางนี้แสดงให้เห็นถึง:

• ไดเรกทอรีใดบ้างที่ถูกเข้าถึง
• เหตุผลที่ไฟล์บางไฟล์ถูกเลือกหรือข้ามไป
• เส้นทางที่แน่นอนที่การเรียกคืนข้อมูลใช้

สำหรับการดีบัก สิ่งนี้มีค่ามาก คุณสามารถดูได้ว่าเอเจนต์พลาดบริบทไปหรือไม่ เพราะมันอยู่ในไดเรกทอรีที่ไม่ถูกต้อง, มีบทคัดย่อ L0 ที่ไม่ดี หรือตกต่ำกว่าเกณฑ์คะแนนที่กำหนดไว้

คุณสมบัติหลัก 5: การจัดการเซสชันอัตโนมัติ

OpenViking มี วงจรการทำซ้ำความทรงจำด้วยตนเอง ที่สร้างมาในตัว เมื่อสิ้นสุดแต่ละเซสชัน ระบบสามารถดึงความทรงจำและอัปเดตความรู้ของเอเจนต์ได้โดยอัตโนมัติ

หกประเภทของความทรงจำ

การทำงานของการดึงความทรงจำ

# เริ่มเซสชัน
session = client.session()

# เพิ่มข้อความ (รอบการสนทนา)
await session.add_message("user", [{"type": "text", "text": "I prefer dark mode in the UI"}])
await session.add_message("assistant", [{"type": "text", "text": "Got it. I'll use dark mode for all future screenshots."}])

# บันทึกการใช้งานเครื่องมือ
await session.add_usage({
    "tool": "screenshot",
    "parameters": {"theme": "dark"},
    "result": "success"
})

# คอมมิตเซสชัน: ทริกเกอร์การดึงความทรงจำ
await session.commit()

เมื่อคอมมิต OpenViking จะ:

1. บีบอัดเซสชัน (เก็บ N รอบล่าสุด, เก็บถาวรที่เก่ากว่า)
2. ดึงความทรงจำโดยใช้การวิเคราะห์ LLM
3. อัปเดตไดเรกทอรีหน่วยความจำที่เหมาะสม
4. สร้าง L0/L1 สำหรับเนื้อหาหน่วยความจำใหม่

สิ่งนี้ทำให้เอเจนต์ ฉลาดขึ้นจากการใช้งาน: พวกเขาเรียนรู้การตั้งค่าของผู้ใช้, สะสมประสบการณ์ในการทำงาน และปรับปรุงการตัดสินใจเมื่อเวลาผ่านไป

ภาพรวมสถาปัตยกรรม

สถาปัตยกรรมระบบของ OpenViking แยกส่วนความรับผิดชอบออกเป็นหลายเลเยอร์:

การจัดเก็บสองเลเยอร์

OpenViking แยกเนื้อหาออกจากดัชนี:

การแยกส่วนนี้ช่วยให้มั่นใจว่า:

• การอ่านเนื้อหาทั้งหมดมาจากแหล่งเดียว (AGFS)
• ดัชนีเวกเตอร์เก็บเฉพาะการอ้างอิงที่มีน้ำหนักเบา
• ไม่มีการทำซ้ำของข้อมูลข้อความขนาดใหญ่ในการจัดเก็บเวกเตอร์

เริ่มต้นอย่างรวดเร็ว: ปรับใช้ OpenViking Server เครื่องแรกของคุณ

ข้อกำหนดเบื้องต้น

• Python: 3.10 ขึ้นไป
• Go: 1.22+ (สำหรับส่วนประกอบ AGFS)
• C++ Compiler: GCC 9+ หรือ Clang 11+
• ระบบปฏิบัติการ: Linux, macOS, หรือ Windows

ขั้นตอนที่ 1: ติดตั้ง OpenViking

pip install openviking --upgrade --force-reinstall

สามารถเลือกติดตั้ง Rust CLI สำหรับการเข้าถึงเทอร์มินัลได้:

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

ขั้นตอนที่ 2: กำหนดค่าโมเดล

OpenViking ต้องการความสามารถของโมเดลสองประเภท:

• โมเดล VLM: สำหรับการทำความเข้าใจรูปภาพและเนื้อหา
• โมเดล Embedding: สำหรับการสร้างเวกเตอร์และการค้นหาเชิงความหมาย

สร้างไฟล์ ~/.openviking/ov.conf:

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

ผู้ให้บริการที่รองรับ:

การรองรับ LiteLLM หมายความว่าคุณสามารถใช้โมเดล Anthropic, Google, Ollama แบบโลคัล หรือปลายทางใด ๆ ที่เข้ากันได้กับ OpenAI ได้

ขั้นตอนที่ 3: เริ่มเซิร์ฟเวอร์

openviking-server

หรือรันในเบื้องหลัง:

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

ขั้นตอนที่ 4: เพิ่มทรัพยากรแรกของคุณ

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

# หรือใช้ Python SDK
from openviking import OpenViking

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

ขั้นตอนที่ 5: ค้นหาและดึงข้อมูล

# รอการประมวลผลเชิงความหมาย จากนั้นค้นหา
ov find "authentication methods"

# แสดงรายการเนื้อหาในไดเรกทอรี
ov ls viking://resources/

# ดูโครงสร้างไดเรกทอรี
ov tree viking://resources/docs -L 2

# ค้นหาเนื้อหาที่เฉพาะเจาะจง
ov grep "OAuth" --uri viking://resources/docs/

ขั้นตอนที่ 6: เปิดใช้งาน VikingBot (ไม่บังคับ)

VikingBot คือเฟรมเวิร์กเอเจนต์ AI ที่สร้างขึ้นบน OpenViking:

pip install "openviking[bot]"

# เริ่มเซิร์ฟเวอร์โดยเปิดใช้งานบอท
openviking-server --with-bot

# ในเทอร์มินัลอื่น, เริ่มแชทแบบโต้ตอบ
ov chat

เกณฑ์มาตรฐานประสิทธิภาพ

OpenViking ได้รับการทดสอบเกณฑ์มาตรฐานเทียบกับ RAG แบบดั้งเดิม (LanceDB) และระบบหน่วยความจำพื้นฐานโดยใช้ชุดข้อมูล LoCoMo10 (1,540 กรณีบทสนทนาระยะยาว)

อัตราการทำงานสำเร็จ

ข้อค้นพบที่สำคัญ

• ปรับปรุงขึ้น 43% เมื่อเทียบกับหน่วยความจำพื้นฐาน โดย ลดโทเค็นได้ 91%
• ปรับปรุงขึ้น 17% เมื่อเทียบกับ LanceDB โดย ลดโทเค็นได้ 92%
• การเรียกคืนข้อมูลแบบลำดับชั้นของ OpenViking พบบริบทที่เกี่ยวข้องมากขึ้นในขณะที่ใช้โทเค็นน้อยลง

ผลลัพธ์เหล่านี้มาจากการรวม OpenViking เป็นปลั๊กอินกับ OpenClaw ซึ่งเป็นผู้ช่วยเขียนโค้ด AI แบบโอเพนซอร์ส ชุดข้อมูลทดสอบอิงจากบทสนทนาระยะยาวที่การเก็บรักษาความทรงจำมีความสำคัญอย่างยิ่ง

การผสานรวม OpenViking กับ Apidog

ผู้ใช้ Apidog ที่สร้างเอเจนต์ AI สำหรับการทดสอบ API สามารถใช้ OpenViking เพื่อรักษาบริบทการสนทนา, จัดเก็บเอกสาร API และจดจำการตั้งค่าของผู้ใช้ในแต่ละเซสชันได้

ขั้นตอนที่ 1: ตั้งค่า OpenViking Server

ทำตามขั้นตอนเริ่มต้นอย่างรวดเร็วด้านบนเพื่อปรับใช้ OpenViking ด้วยโมเดล VLM และ embedding ที่คุณต้องการ

ขั้นตอนที่ 2: นำเข้าเอกสาร Apidog API

# เพิ่มเอกสารโปรเจกต์ Apidog ของคุณเป็นทรัพยากร
ov add-resource https://docs.apidog.com/overview
ov add-resource https://docs.apidog.com/api-testing

สิ่งนี้จะนำเข้าเอกสาร Apidog เข้าสู่ viking://resources/ พร้อมการประมวลผล L0/L1/L2 โดยอัตโนมัติ

ขั้นตอนที่ 3: จัดเก็บการตั้งค่าของผู้ใช้

from openviking import OpenViking

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

# บันทึกการตั้งค่าสภาพแวดล้อมเริ่มต้นของผู้ใช้
await session.add_message("user", [{
    "type": "text",
    "text": "Always use the staging environment for API tests"
}])
await session.commit()  # ดึงความทรงจำการตั้งค่าโดยอัตโนมัติ

ขั้นตอนที่ 4: สอบถามบริบทระหว่างการทดสอบ

# ค้นหาปลายทาง API ที่เกี่ยวข้องก่อนรันการทดสอบ
results = client.find("authentication endpoints")
for ctx in results.resources:
    print(f"Found: {ctx.uri}")

# ดึงการตั้งค่าสภาพแวดล้อมของผู้ใช้
prefs = client.find("staging environment preference", target_uri="viking://user/memories/")

ขั้นตอนที่ 5: เชื่อมต่อกับ Agent Framework ของคุณ

OpenViking เปิดเผยทั้ง Python SDK และ HTTP API:

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

# หรือ HTTP API
import httpx
response = httpx.post(
    "http://localhost:1933/api/v1/search/find",
    json={"query": "authentication endpoints"},
    headers={"X-API-Key": "your-api-key"}
)

เทคนิคขั้นสูงและแนวปฏิบัติที่ดีที่สุด

เคล็ดลับสำหรับผู้เชี่ยวชาญสำหรับการปรับใช้ในการผลิต

1. อุ่นบริบทที่เข้าถึงบ่อยล่วงหน้า

โหลดเอกสารสำคัญเข้าสู่ L0/L1 ในช่วงนอกเวลาทำการเพื่อลดความล่าช้าระหว่างการทำงานของเอเจนต์

# ทริกเกอร์การประมวลผลเชิงความหมายทันที
ov add-resource https://docs.example.com --wait

2. ใช้การหมดอายุของบริบท

ตั้งค่าการล้างข้อมูลเซสชันที่ล้าสมัยโดยอัตโนมัติ:

# เก็บถาวรเซสชันที่เก่ากว่า 7 วัน
await session.archive(max_age_days=7)

3. ตรวจสอบสถานะดัชนีเวกเตอร์

ติดตามขนาดดัชนีและความล่าช้าในการสอบถาม:

ov debug stats

ข้อผิดพลาดทั่วไปที่ควรหลีกเลี่ยง

1. โหลดเนื้อหา L2 ก่อนเวลาอันควร: ควรเริ่มต้นด้วย L0/L1 เสมอเพื่อประหยัดโทเค็น
2. ข้ามการคอมมิตเซสชัน: การดึงความทรงจำจะเกิดขึ้นเมื่อมีการคอมมิตเท่านั้น
3. การโหลดไดเรกทอรีเดียวมากเกินไป: แบ่งทรัพยากรขนาดใหญ่เป็นไดเรกทอรีย่อยตามหัวข้อ
4. เพิกเฉยต่อเส้นทางการเรียกคืนข้อมูล: ใช้เส้นทางที่แสดงภาพเพื่อดีบักผลลัพธ์ที่ไม่ดี

การเพิ่มประสิทธิภาพ

แนวปฏิบัติที่ดีที่สุดด้านความปลอดภัย

• จัดเก็บ API keys ในตัวแปรสภาพแวดล้อมหรือผู้จัดการความลับ (ห้ามเก็บในไฟล์ config เด็ดขาด)
• เปิดใช้งาน HTTPS สำหรับการปรับใช้ HTTP server ทั้งหมด
• ใช้การจำกัดอัตรา (rate limiting) บนปลายทางสาธารณะ
• ใช้ API keys แยกกันสำหรับการพัฒนาและโปรดักชัน

กรณีการใช้งานจริง

1. ผู้ช่วยเขียนโค้ด AI

ทีมพัฒนาได้ผสานรวม OpenViking เข้ากับผู้ช่วยเขียนโค้ดภายในของพวกเขา ตอนนี้เอเจนต์สามารถ:

• นำทางโครงสร้างโปรเจกต์ผ่าน viking://resources/my_project/src/
• จดจำการตั้งค่าการเขียนโค้ดของผู้ใช้ (ข้อกำหนดการตั้งชื่อ, เฟรมเวิร์กการทดสอบ)
• ดึงเอกสาร API ที่เกี่ยวข้องระหว่างการสร้างโค้ด

ผลลัพธ์: ลดพฤติกรรมเอเจนต์ “ขี้ลืม” ได้ 67% ประหยัดค่าโทเค็นได้ 43%

2. เอเจนต์ฝ่ายสนับสนุนลูกค้า

บริษัท SaaS แห่งหนึ่งได้ปรับใช้ OpenViking สำหรับแชทบอทสนับสนุนลูกค้า:

• เอกสารผลิตภัณฑ์จัดเก็บอยู่ใน viking://resources/product/
• ประวัติการสนทนาของลูกค้าอยู่ใน viking://user/memories/past_issues/
• คู่มือการสนับสนุนในรูปแบบทักษะใน viking://agent/skills/

ผลลัพธ์: การแก้ไขปัญหาในครั้งแรกดีขึ้นจาก 52% เป็น 71%

3. ผู้ช่วยงานวิจัย

ห้องปฏิบัติการวิจัยแห่งหนึ่งใช้ OpenViking ในการจัดระเบียบเอกสารและบันทึก:

• เอกสารที่จัดหมวดหมู่ตามหัวข้อ (viking://resources/papers/nlp/)
• ระเบียบวิธีวิจัยจัดเก็บเป็นทักษะ
• การดึงผลการค้นพบที่สำคัญเข้าสู่หน่วยความจำโดยอัตโนมัติ

ผลลัพธ์: นักวิจัยพบเอกสารที่เกี่ยวข้องเร็วขึ้น 3 เท่าด้วยการค้นหาเชิงความหมาย

ทางเลือกและการเปรียบเทียบ

OpenViking ไม่ใช่โซลูชันการจัดการบริบทเพียงอย่างเดียว นี่คือการเปรียบเทียบกับทางเลือกอื่น:

OpenViking เทียบกับฐานข้อมูลเวกเตอร์แบบดั้งเดิม