Openviking Context Database
Install and wire OpenViking as a unified context database so your agent gets tiered memory, resources, and skills instead of ad-hoc vector chunks.
Overview
OpenViking Context Database is an agent skill for the Build phase that guides setup and integration of OpenViking’s filesystem-style context database for agent memory, resources, and skills.
Install
npx skills add https://github.com/aradotso/trending-skills --skill openviking-context-databaseWhat is this skill?
- Filesystem-paradigm context DB with tiered L0/L1/L2 structure for memory, resources, and skills
- pip install openviking with optional Rust ov_cli for operations and AGFS-related components
- Documented triggers: LLM provider setup, agent memory, skills setup, and RAG-style retrieval
- Hierarchical context delivery and observable retrieval trajectories for debugging agent recall
- Prerequisites called out: Python 3.10+, Go 1.22+ for AGFS, GCC 9+ or Clang 11+ for extensions
- Tiered L0/L1/L2 context structure
- Python 3.10+ prerequisite
- Optional Rust ov_cli install
Adoption & trust: 1.2k installs on skills.sh; 31 GitHub stars; 1/3 security scanners passed (skills.sh audits).
What problem does it solve?
Your agent’s memory and skills live in scattered vector chunks with no unified hierarchy, making setup, debugging, and retrieval opaque.
Who is it for?
Indie agent builders who want OpenViking-backed memory, RAG, and skill storage with documented install paths and trigger-driven setup steps.
Skip if: Teams that only need a simple in-memory chat history or a managed proprietary vector DB with no self-hosted OpenViking footprint.
When should I use this skill?
Set up OpenViking, configure LLM provider, add agent memory, or integrate OpenViking RAG per SKILL.md triggers.
What do I get? / Deliverables
OpenViking is installed and configured with your LLM provider so the agent can store, tier, and query context through a single observable context database.
- OpenViking installation and upgrade commands
- Configured context database wired to agent retrieval
Recommended Skills
Journey fit
Build is where you integrate persistence and retrieval into the product; OpenViking is infrastructure you embed during agent development. Integrations subphase matches connecting an external context store, LLM provider, and optional RAG/query paths into your agent stack.
How it compares
Self-hosted context database integration—not a hosted MCP-only memory stub or generic prompt library.
Common Questions / FAQ
Who is openviking-context-database for?
Developers building custom AI agents who need OpenViking for memory, resources, skills, and RAG instead of piecing together separate vector stores.
When should I use openviking-context-database?
During Build when you set up OpenViking, connect an LLM provider, add agent memory, or integrate filesystem-style context management and queries.
Is openviking-context-database safe to install?
Check Prism’s Security Audits panel and review OpenViking upstream packages and install scripts before running them in production environments.
SKILL.md
READMESKILL.md - Openviking Context Database
# OpenViking Context Database > Skill by [ara.so](https://ara.so) — Daily 2026 Skills collection. OpenViking is an open-source **context database** for AI Agents that replaces fragmented vector stores with a unified **filesystem paradigm**. It manages agent memory, resources, and skills in a tiered L0/L1/L2 structure, enabling hierarchical context delivery, observable retrieval trajectories, and self-evolving session memory. --- ## Installation ### Python Package ```bash pip install openviking --upgrade --force-reinstall ``` ### Optional Rust CLI ```bash # Install via script curl -fsSL https://raw.githubusercontent.com/volcengine/OpenViking/main/crates/ov_cli/install.sh | bash # Or build from source (requires Rust toolchain) cargo install --git https://github.com/volcengine/OpenViking ov_cli ``` ### Prerequisites - Python 3.10+ - Go 1.22+ (for AGFS components) - GCC 9+ or Clang 11+ (for core extensions) --- ## Configuration Create `~/.openviking/ov.conf`: ```json { "storage": { "workspace": "/home/user/openviking_workspace" }, "log": { "level": "INFO", "output": "stdout" }, "embedding": { "dense": { "api_base": "https://api.openai.com/v1", "api_key": "$OPENAI_API_KEY", "provider": "openai", "dimension": 1536, "model": "text-embedding-3-large" }, "max_concurrent": 10 }, "vlm": { "api_base": "https://api.openai.com/v1", "api_key": "$OPENAI_API_KEY", "provider": "openai", "model": "gpt-4o", "max_concurrent": 100 } } ``` > **Note:** OpenViking reads `api_key` values as strings; use environment variable injection at startup rather than literal secrets. ### Provider Options | Role | Provider Value | Example Model | |------|---------------|---------------| | VLM | `openai` | `gpt-4o` | | VLM | `volcengine` | `doubao-seed-2-0-pro-260215` | | VLM | `litellm` | `claude-3-5-sonnet-20240620`, `ollama/llama3.1` | | Embedding | `openai` | `text-embedding-3-large` | | Embedding | `volcengine` | `doubao-embedding-vision-250615` | | Embedding | `jina` | `jina-embeddings-v3` | ### LiteLLM VLM Examples ```json { "vlm": { "provider": "litellm", "model": "claude-3-5-sonnet-20240620", "api_key": "$ANTHROPIC_API_KEY" } } ``` ```json { "vlm": { "provider": "litellm", "model": "ollama/llama3.1", "api_base": "http://localhost:11434" } } ``` ```json { "vlm": { "provider": "litellm", "model": "deepseek-chat", "api_key": "$DEEPSEEK_API_KEY" } } ``` --- ## Core Concepts ### Filesystem Paradigm OpenViking organizes agent context like a filesystem: ``` workspace/ ├── memories/ # Long-term agent memories (L0 always loaded) │ ├── user_prefs/ │ └── task_history/ ├── resources/ # External knowledge, documents (L1 on demand) │ ├── codebase/ │ └── docs/ └── skills/ # Reusable agent capabilities (L2 retrieved) ├── coding/ └── analysis/ ``` ### Tiered Context Loading (L0/L1/L2) - **L0**: Always loaded — core identity, persistent preferences - **L1**: Loaded on demand — relevant resources fetched per task - **L2**: Semantically retrieved — skills pulled by similarity search This tiered approach minimizes token consumption while maximizing context relevance. --- ## Python API Usage ### Basic Setup ```python import os from openviking import OpenViking # Initialize with config file ov = OpenViki