Search tools, AI agents, MCP servers
Submit a tool

Search iThub

Search tools, categories and collections. Type at least two characters.

Explore all tools
↑ ↓ to explore resultsEnter to open · Esc to close

OpenViking

Open-source context database that stores AI agent memory, resources and skills as a viking:// filesystem

LLM App Platforms & RAGFreemiumv0.5.5

OpenViking at a glance

Pricing
Freemium
Deployment
Self-hosted
License
Open source
Version
v0.5.5November 13, 2026
Platforms
WebWindowsmacOSLinux
Language
Python
Data location
Self-hosted: content, vectors and memories stay in the configured storage, with text sent to the chosen embedding and VLM providers; the managed OpenViking Service uses a Volcengine cn-beijing endpoint.
Maker
volcengine
Founded
2026

What is OpenViking?

OpenViking is an open-source context database for AI agents. It stores the three kinds of context an agent works with, resources (documents, code, web pages), memories (user preferences, events, agent experience) and skills (task instructions), as files in one virtual filesystem addressed by viking:// URIs. Agents and people browse it with filesystem-style operations such as ls, tree, read, write and grep, and every semantically processed directory carries generated summaries so an agent can check relevance before opening full content (project README).

According to the official Team & Org page, OpenViking was initiated and is maintained by the Viking team at ByteDance's Volcengine (Volcano Engine). The page traces it back to VikingDB, used inside ByteDance from 2019 to 2023, and to the Viking cloud products Volcano Engine has sold since 2024. The team open-sourced MineContext in late 2025 and OpenViking in early 2026; the GitHub repository was created in January 2026. The project lists research papers written with university partners, among them VikingMem (VLDB 2026), whose mechanisms are partly integrated into the code.

OpenViking runs as an HTTP server (openviking-server, default address 127.0.0.1:1933). It is published on PyPI as openviking for Python 3.10 or later, with wheels for macOS on Apple silicon and Intel, Linux x86_64 and aarch64, and Windows x64; the package metadata lists the development status as Alpha. A prebuilt image is published at ghcr.io/volcengine/openviking, and the server bundles the Web Studio UI at /studio. Clients include the ov CLI, SDKs, an HTTP API, an MCP endpoint and agent memory plugins. Volcengine also runs the same software as a managed service, OpenViking Service (first 50 files free, Personal and Enterprise plans), and offers a Self-Managed commercial edition with distributed deployment and official support activated by a license key.

The latest GitHub release is v0.5.5, published on November 13, 2026, together with Python SDK 0.1.20 and standalone CLI 0.5.3. It adds a PostgreSQL deployment option (a pgvector vector backend with exact or HNSW search, plus a PostgreSQL path lock) so multi-host deployments no longer need Redis, a storage.agfs.coordination setting for multi-node coordination, an indexed snapshot path history, peer-scoped recall and memory-type filters for Gateway context profiles, and a batch tag endpoint. v0.5.4 (November 9, 2026) added MCP live-context mounts and distributed Watches.

The main project is licensed under AGPLv3 and the open-source server needs no activation key. The crates/ov_cli CLI and the examples folder are Apache 2.0, and the framework adapters use AGPLv3 (LangChain/LangGraph) or MIT (Microsoft Agent Framework). The README adds that wholesale rewriting and re-open-sourcing of the project is prohibited and that translating substantial parts of the code into another language requires written authorization from Volcano Engine. The desktop app and OpenViking Gateway are labeled beta. Projects with a similar focus on iThub include Mem0, Cognee and Letta.

Key capabilities

  • Virtual filesystem for agent context All context lives under viking://: resources/ for shared documents and repositories, and user/{user_id}/ with memories/, resources/, skills/ and peers/. Each item has a URI that can be listed, read, moved or deleted, and moves and deletions are synchronized with the vector index (Viking URI docs).
  • L0, L1 and L2 context layers Semantic processing writes a one-sentence abstract (.abstract.md, L0) and an overview (.overview.md, L1) for directories, while the full original data is L2 and is read only when needed. Summaries are generated asynchronously from the bottom up by a semantic queue, so a directory may lack sidecars until processing finishes (context layers).
  • Directory-scoped retrieval find runs a semantic query directly and search first runs intent analysis that produces zero to five typed queries from session context; both can be limited to a directory subtree instead of the whole index. An optional rerank pass orders the candidates. grep and glob cover text and path matching (retrieval docs).
  • Sessions and memory extraction Conversation messages and usage are recorded in sessions. Committing a session archives the history with its own summaries and extracts memories according to the memory policy and MemoryType schemas, merging and deduplicating them with an LLM. Extracted memories are Markdown files that can be read, edited and merged; extraction runs in the background, so new memories are not available immediately.
  • Resource import and parsing add_resource imports files, directories, URLs and Git repositories such as a GitHub URL, and creates a background task that runs document parsing, semantic processing and vector embedding. Parsing covers formats such as PDF, Markdown and HTML. Since v0.5.5 a first non-strict import can partially succeed and reports the failed files.
  • Context compilation With VikingBot or another configured Agent Runtime, ov compile reads source directories and uses an installed skill to write a wiki, knowledge graph, daily report or other output back into OpenViking. Runs take --from, --to and --skill arguments and return a task ID; ov compile memory consolidates the current user's existing memories (context compilation).
  • Web Studio The Studio web interface is served by the server at /studio. Its pages include Home (context volume, token and retrieval counts), Filesystem with Markdown preview, Retrieval with find, search, grep and glob, Skills, Compile, Sessions, Agent Experience, Request Logs, Task Center, Scheduled Sync, Monitoring and Gateway management.
  • Agent integrations The official integration list covers Claude Code, Codex, Cursor, TRAE, CodeBuddy Code, Qoder CLI, DeepSeek Harness, OpenCode and pi through hooks plus MCP or native plugins, OpenClaw as a context engine, Hermes Agent through a memory plugin, and LangChain/LangGraph through a retriever, tools and store. A one-line installer detects installed agents; it needs macOS or Linux, Node.js 18 or later and curl (integration overview).
  • MCP endpoint and Agent Plugins package The server exposes a Streamable HTTP MCP endpoint at /mcp for clients such as Claude Desktop and ChatGPT, authenticated with a bearer API key. Stdio-only clients can use the proxy in the Agent Plugins 1.0 package (MCP clients).
  • OpenViking Gateway (beta) A model API proxy for clients that cannot install a plugin: the client changes its base URL and uses an ovgw_ gateway key. For each new user message the gateway recalls memory and appends it, replays earlier additions byte for byte for prompt caching, saves turns to OpenViking sessions and compacts long conversations. It supports Anthropic Messages, OpenAI Chat Completions and OpenAI Responses and never converts between them (Gateway guide).
  • Model provider support The openviking-server init wizard configures an embedding model and a VLM separately, with VLM options including Volcengine, OpenAI, OpenAI Codex OAuth, Kimi, GLM and local Ollama. Embedding providers include OpenAI, Azure, Volcengine, Jina, Ollama, Gemini, Voyage, Cohere and LiteLLM; without configuration the server uses a local 512-dimension GGUF model, bge-small-zh-v1.5-f16.
  • Storage backends Content and index are stored separately: file content in AGFS/RAGFS on local disk, S3-compatible storage or memory, and vectors in a backend chosen from local, http, volcengine, vikingdb, cuvs (NVIDIA GPU search on Linux), opengauss and pgvector. Embedded vector backends lock the workspace, so multi-instance setups use a remote backend.
  • Accounts, roles and access control One server can host several accounts. Resources are shared inside an account, memories and sessions are isolated per user, and ROOT, ADMIN and USER roles manage permissions. Opt-in ACLs grant access per directory or file, and the docs require authentication to be configured before the server is exposed beyond localhost (multi-tenant model).
  • Encryption and privacy configs At-rest encryption encrypts files before storage with a separate key for each account while keeping the client API unchanged. Privacy configs detect sensitive values such as API keys and tokens in skills and sessions at write time, store them with version history in the user's privacy space and replace them with placeholders that are restored on read.
  • Snapshots, OVPack and WebDAV Snapshots record version history for content, with an indexed path history since v0.5.5. OVPack exports and imports viking://resources or user trees as a checksummed ZIP with sidecars and optional vector snapshots; the docs note that exported packages are plaintext even when storage is encrypted. A WebDAV adapter at /webdav/resources exposes resources only, with UTF-8 text writes.
  • VikingBot VikingBot is an agent framework built on OpenViking, installed with pip install "openviking[bot]" and started with openviking-server --with-bot; ov chat opens a terminal chat. The official Docker image starts it by default next to the server and can disable it with --without-bot.
  • SDKs, CLI and HTTP API The ov CLI ships with the Python package and as a standalone binary, and covers status, resource import, task status, listing, tree, find, grep, tags and compile. The HTTP API sits under /api/v1 with X-API-Key authentication, and SDKs exist for Python (openviking-sdk), Go and TypeScript (API overview).
  • Server installation The documented self-hosted path is uv tool install openviking --upgrade followed by openviking-server init, which writes ~/.openviking/ov.conf; openviking-server doctor validates configuration, model access and authentication. A self-hosted server needs uv, Python 3.10 or later and a model provider with an embedding model and a VLM. Linux deployments can run it as a systemd service (deployment guide).
  • Docker and cloud deployment The Docker image maps port 1933 and mounts ~/.openviking to /app/.openviking; because it binds to 0.0.0.0 inside the container, a root_api_key is required. An alternative image is published at openviking-cn-beijing.cr.volces.com,Docker Compose adds a Caddy entry point on port 1934, and the Railway template provisions a volume and preconfigures OpenAI defaults.
  • Desktop app (beta) OpenViking Helper is a desktop console for macOS (Apple silicon and Intel) and Windows x64, version 0.0.19 in the README. It configures supported local agent integrations, shows recall and capture events in sessions, and syncs local memories and skills to OpenViking.

Where OpenViking fits

Persistent memory for coding agents

The README describes connecting Claude Code, Codex, Cursor, TRAE, OpenCode and other agents through the memory plugin installer (curl -fsSL https://openviking.ai/install | bash), which asks for the tools, the server and a user key. The plugins recall relevant memories before a turn and capture turns afterwards, so a preference stated in one session can be recalled in a later one once background extraction has run. A root key cannot read or write memories, so the installer uses a user key, stored in ~/.openviking/ovcli.conf.

Searchable knowledge base from repositories and documents

The quick start imports a GitHub repository with ov add-resource, polls ov task status until processing completes, then explores it with ov ls, ov tree, ov find and ov grep. Retrieval can be scoped to one directory, and results point to L0 abstracts or L2 files whose URIs can be passed to an agent or opened in Studio.

Memory for chat apps and SDK clients through the Gateway

For chat applications, scripts and low-code platforms that only allow a base URL and API key, the beta OpenViking Gateway adds recall, tool calls and conversation saving without client changes. It runs embedded in the server under /gateway or as a standalone openviking-gateway process against an existing service, keeps its own state in SQLite or shared Redis, and continues conversations without memory if OpenViking is unavailable (how the Gateway works).

Team deployment with shared resources and private memories

A single server can serve several teams as accounts, with shared resources inside an account, per-user memories and sessions, role-based keys, per-path ACLs and optional per-account encryption. Multi-host setups described in v0.5.5 use pgvector and the PostgreSQL path lock, or other remote vector backends, plus shared temporary uploads and per-instance queue databases.

Compiling sources into wikis and reports

The context compilation feature organizes imported material with a skill: the documented examples build an LLM wiki, a knowledge graph, a daily report and distilled knowledge, and consolidate existing memories. Compilation runs as an asynchronous agent loop under the requesting user's identity and writes its output to a target viking:// directory.

Long-term memory benchmarks

The project reports results for OpenViking 0.3.22 in its benchmark report, using Doubao 2.0 Pro as the VLM and Doubao-embedding-vision-251215 for embeddings. On LoCoMo it lists accuracy of 82.08% for OpenClaw (24.20% with native memory), 82.86% for Hermes (33.38%) and 80.32% for Claude Code (57.21%), with input tokens down 34.3% to 91.0% and query latency down 58.45% to 66.10%. On tau2-bench, experience memory raised task success by 6.87 points in retail and 11.87 points in airline. Reproduction scripts are in the repository's benchmark folder.

Install

uv tool install openviking --upgrade && openviking-server init

Reviews of OpenViking

No reviews yet

Be the first to share your experience with OpenViking.

Loading review form…

Found OpenViking useful? Upvote it todayYour vote helps other IT teams find it in the daily ranking.

Similar to OpenViking

Compare:OpenViking vs Mem0OpenViking vs CogneeOpenViking vs Letta

  1. Mem0Apache-2.0 memory layer that gives AI agents persistent per-user memory, self-hosted or as a managed serviceLLM App Platforms & RAG0 views
  2. CogneeCognee gives AI agents persistent memory built from documents, code, and conversations.LLM App Platforms & RAG0 views
  3. LettaStateful agent harness with persistent memory and identity.Agent Frameworks0 views
  4. DifyPlatform for building LLM apps with a visual workflow canvas, RAG pipelines, agents and APIsLLM App Platforms & RAG44 views
  5. FlowiseVisual agent builder that is being wound downLLM App Platforms & RAG13 views
  6. LiteLLMOpen-source AI gateway and Python SDK that calls 100+ LLM providers through one OpenAI-style APILLM App Platforms & RAG4 views
  7. AgentaOpen-source workspace where teams build AI agents by chatting, share them and run them as automationsLLM App Platforms & RAG3 views
  8. BotpressHosted platform for LLM chat agents, with MIT-licensed integrations, SDK and CLI on GitHubLLM App Platforms & RAG2 views