Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.
Python agent-contextagent-memoryagent-pluginsagentic-ragcontext-databasedsh-pluginknowledge-basememorymemory-managementself-evolvingvector-database
# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
# SPDX-License-Identifier: AGPL-3.0
import asyncio
import contextvars
import json
from types import SimpleNamespace
from unittest.mock import AsyncMock, MagicMock
import pytest
from openviking.server.identity import RequestContext, Role
from openviking.storage.viking_fs import VikingFS
from openviking_cli.retrieve.types import ContextType, MatchedContext, QueryResult
from openviking_cli.session.user_id import UserIdentifier
from openviking_cli.utils.config.retrieval_config import RetrievalConfig
def _ctx() -> RequestContext:
return RequestContext(user=UserIdentifier("acc1", "user1"), role=Role.USER)
def _make_viking_fs(*, enable_intent: bool) -> VikingFS:
fs = VikingFS.__new__(VikingFS)
fs.agfs = MagicMock()
fs.acl_manager = None
fs.query_embedder = MagicMock(name="embedder")
fs.rerank_config = None
fs.retrieval_config = RetrievalConfig(enable_intent=enable_intent)
fs.vector_store = MagicMock(name="vector_store")
fs._bound_ctx = contextvars.ContextVar("vikingfs_bound_ctx_intent_test", default=None)
fs._ensure_access = AsyncMock()
fs._get_vector_store = MagicMock(return_value=fs.vector_store)
fs._get_embedder = MagicMock(return_value=fs.query_embedder)
fs._ctx_or_default = MagicMock(return_value=_ctx())
fs.abstract = AsyncMock(return_value="")
return fs
def test_retrieval_config_enable_intent_defaults_true():
cfg = RetrievalConfig()
assert cfg.enable_intent is True
def test_retrieval_config_enable_intent_can_disable():
cfg = RetrievalConfig(enable_intent=False)
assert cfg.enable_intent is False
@pytest.mark.asyncio
async def test_search_skips_intent_and_uses_raw_query_when_disabled(monkeypatch):
fs = _make_viking_fs(enable_intent=False)
captured = {}
class ForbiddenIntentAnalyzer:
def __init__(self, *args, **kwargs):
raise AssertionError("intent analysis must not run when disabled")
class FakeRetriever:
def __init__(self, storage, embedder, rerank_config):
pass
async def retrieve(self, typed_query, **kwargs):
captured["typed_query"] = typed_query
return QueryResult(
query=typed_query,
matched_contexts=[],
searched_directories=typed_query.target_directories,
)
monkeypatch.setattr(
"openviking.retrieve.intent_analyzer.IntentAnalyzer",
ForbiddenIntentAnalyzer,
)
monkeypatch.setattr(
"openviking.retrieve.hierarchical_retriever.HierarchicalRetriever",
FakeRetriever,
)
result = await fs.search(
"raw query",
target_uri="viking://resources/docs",
session_info={
"latest_archive_overview": "previous summary",
"current_messages": [{"role": "user", "content": "previous turn"}],
},
ctx=_ctx(),
)
assert result.query_plan is None
assert captured["typed_query"].query == "raw query"
assert captured["typed_query"].intent == ""
assert captured["typed_query"].target_directories == ["viking://resources/docs"]
def test_search_service_is_intent_enabled_follows_config():
from openviking.service.search_service import SearchService
svc = SearchService(_make_viking_fs(enable_intent=False))
assert svc.is_intent_enabled() is False
svc.set_viking_fs(_make_viking_fs(enable_intent=True))
assert svc.is_intent_enabled() is True
empty = SearchService()
assert empty.is_intent_enabled() is True
@pytest.mark.asyncio
async def test_search_service_skips_session_context_when_intent_disabled():
from openviking.service.search_service import SearchService
fs = _make_viking_fs(enable_intent=False)
fs.search = AsyncMock(return_value=MagicMock(name="find_result", query_plan=None, total=0))
session = MagicMock()
session.get_context_for_search = AsyncMock(
side_effect=AssertionError("must not scan session when intent disabled")
)
svc = SearchService(fs)
await svc.search(query="hello", ctx=_ctx(), session=session, target_uri="")
session.get_context_for_search.assert_not_awaited()
assert fs.search.await_args.kwargs.get("session_info") is None
@pytest.mark.asyncio
async def test_search_service_loads_session_context_when_intent_enabled():
from openviking.service.search_service import SearchService
fs = _make_viking_fs(enable_intent=True)
fs.search = AsyncMock(return_value=MagicMock(name="find_result", query_plan=None, total=0))
session_info = {"latest_archive_overview": "ov", "current_messages": []}
session = MagicMock()
session.get_context_for_search = AsyncMock(return_value=session_info)
svc = SearchService(fs)
await svc.search(query="hello", ctx=_ctx(), session=session, target_uri="")
session.get_context_for_search.assert_awaited_once()
assert fs.search.await_args.kwargs.get("session_info") is session_info
@pytest.mark.asyncio
@pytest.mark.parametrize(
("scope", "planned", "expected"),
[
("memory", "resource", "memory"),
(["memory"], "skill", "memory"),
("resource", "memory", "resource"),
(["memory", "resource"], "memory", "memory"),
(["memory", "resource"], "skill", None),
(None, "skill", "skill"),
],
)
async def test_session_search_plan_respects_explicit_context_scope(
monkeypatch, scope, planned, expected
):
# #5544: planner classification must not contradict the caller's REST scope.
from starlette.requests import Request
from openviking.server.routers import search as search_router
from openviking.service.search_service import SearchService
fs = _make_viking_fs(enable_intent=True)
planner = SimpleNamespace(
get_completion_async=AsyncMock(
return_value=json.dumps(
{"queries": [{"query": "known record", "context_type": planned}]}
)
)
)
fs._vlm_resolver = SimpleNamespace(get_query_planner=AsyncMock(return_value=planner))
session = SimpleNamespace(
load=AsyncMock(),
get_context_for_search=AsyncMock(
return_value={"latest_archive_overview": "previous discussion"}
),
)
service = SimpleNamespace(
search=SearchService(fs),
sessions=SimpleNamespace(session=lambda *args: session),
)
class FakeRetriever:
def __init__(self, **kwargs):
pass
async def retrieve(self, typed_query, **kwargs):
return QueryResult(query=typed_query, matched_contexts=[], searched_directories=[])
monkeypatch.setattr(search_router, "get_service", lambda: service)
monkeypatch.setattr(
"openviking.retrieve.hierarchical_retriever.HierarchicalRetriever", FakeRetriever
)
response = await search_router.search(
search_router.SearchRequest(query="known record", session_id="fixture", context_type=scope),
Request({"type": "http"}),
_ctx(),
)
assert response["status"] == "ok"
assert response["result"]["query_plan"]["queries"][0]["context_type"] == expected
@pytest.mark.asyncio
@pytest.mark.parametrize("failure", ["timeout", "provider"])
async def test_session_search_falls_back_when_intent_planning_fails(monkeypatch, failure):
from starlette.requests import Request
from openviking.server.routers import search as search_router
from openviking.service.search_service import SearchService
fs = _make_viking_fs(enable_intent=True)
fs.retrieval_config = RetrievalConfig(recall_intent_timeout_s=0.02)
async def failed_completion(prompt):
if failure == "timeout":
await asyncio.Event().wait()
raise RuntimeError("provider overloaded")
planner = SimpleNamespace(get_completion_async=failed_completion)
fs._vlm_resolver = SimpleNamespace(get_query_planner=AsyncMock(return_value=planner))
session = SimpleNamespace(
load=AsyncMock(),
get_context_for_search=AsyncMock(
return_value={"latest_archive_overview": "previous discussion"}
),
)
service = SimpleNamespace(
search=SearchService(fs),
sessions=SimpleNamespace(session=lambda *args: session),
)
match = MatchedContext(
uri="viking://resources/docs/answer.md", context_type=ContextType.RESOURCE
)
async def retrieve(typed_query, **kwargs):
assert typed_query.query == "raw query"
assert typed_query.target_directories == ["viking://resources/docs"]
return QueryResult(
query=typed_query,
matched_contexts=[match],
searched_directories=typed_query.target_directories,
)
monkeypatch.setattr(search_router, "get_service", lambda: service)
monkeypatch.setattr(
"openviking.retrieve.hierarchical_retriever.HierarchicalRetriever",
lambda **kwargs: SimpleNamespace(retrieve=retrieve),
)
response = await asyncio.wait_for(
search_router.search(
search_router.SearchRequest(
query="raw query", session_id="fixture", target_uri="viking://resources/docs"
),
Request({"type": "http"}),
_ctx(),
),
timeout=1.0,
)
assert response["status"] == "ok"
assert response["result"]["resources"][0]["uri"] == match.uri
assert "query_plan" not in response["result"]