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
fix(langchain): preserve recall inputs and context metadata (#6338)
z1gon7c12d3062fec
diff --git a/integrations/frameworks/langchain/src/langchain_openviking/context.py b/integrations/frameworks/langchain/src/langchain_openviking/context.pyindex 9dcc824bc..8421d3f72 100644--- a/integrations/frameworks/langchain/src/langchain_openviking/context.py+++ b/integrations/frameworks/langchain/src/langchain_openviking/context.py@@ -314,7 +314,9 @@ class OpenVikingSessionContextAssembler:block = self._format_context_block(session_context, recall_documents)return OpenVikingAssembledContext(block=block,- context_parts=context_parts_from_documents(recall_documents),+ context_parts=context_parts_from_documents(+ recall_documents, metadata_prefix=self.retriever.metadata_prefix+ ),session_context=session_context,recall_documents=recall_documents,)@@ -911,6 +913,9 @@ def _latest_user_text_from_input(input_value: Any, input_messages_key: str | Nonif isinstance(input_value, str):return input_valueif isinstance(input_value, dict):+ value = input_value.get(input_messages_key or "messages")+ if isinstance(value, str):+ return value.strip()for value in input_value.values():if isinstance(value, str) and value.strip():return value.strip()@@ -918,13 +923,13 @@ def _latest_user_text_from_input(input_value: Any, input_messages_key: str | Nondef _input_messages(input_value: Any, input_messages_key: str | None) -> list[Any]:- if isinstance(input_value, list):- return list(input_value)if isinstance(input_value, dict):key = input_messages_key or "messages"- value = input_value.get(key)- if isinstance(value, list):- return list(value)+ input_value = input_value.get(key)+ if isinstance(input_value, (list, tuple)):+ return list(input_value)+ if isinstance(input_value, BaseMessage):+ return [input_value]return []@@ -933,13 +938,17 @@ def _inject_system_context(context_block: str,input_messages_key: str | None,) -> Any:- if isinstance(input_value, list):- return _merge_system_message(input_value, context_block)+ if isinstance(input_value, (list, tuple, BaseMessage)):+ return _merge_system_message(+ _input_messages(input_value, input_messages_key), context_block+ )if isinstance(input_value, dict):key = input_messages_key or "messages"- if isinstance(input_value.get(key), list):+ if isinstance(input_value.get(key), (list, tuple, BaseMessage)):updated = dict(input_value)- updated[key] = _merge_system_message(input_value[key], context_block)+ updated[key] = _merge_system_message(+ _input_messages(input_value, input_messages_key), context_block+ )return updatedupdated = dict(input_value)updated["openviking_context"] = context_block@@ -951,8 +960,12 @@ def _merge_system_message(messages: Sequence[Any], context_block: str) -> list[Aupdated = list(messages)for index, message in enumerate(updated):if isinstance(message, SystemMessage):- content = extract_message_text(message.content)- updated[index] = SystemMessage(content=f"{content}\n\n{context_block}".strip())+ content = (+ [*deepcopy(message.content), {"type": "text", "text": context_block}]+ if isinstance(message.content, list)+ else f"{extract_message_text(message.content)}\n\n{context_block}".strip()+ )+ updated[index] = message.model_copy(update={"content": content})return updatedreturn [SystemMessage(content=context_block), *updated]diff --git a/integrations/frameworks/langchain/src/langchain_openviking/history.py b/integrations/frameworks/langchain/src/langchain_openviking/history.pyindex 38a8a0dab..54e8eb7d0 100644--- a/integrations/frameworks/langchain/src/langchain_openviking/history.py+++ b/integrations/frameworks/langchain/src/langchain_openviking/history.py@@ -269,21 +269,23 @@ class OpenVikingChatMessageHistory(BaseChatMessageHistory):)-def context_parts_from_documents(documents: Sequence[Any]) -> list[dict[str, Any]]:+def context_parts_from_documents(+ documents: Sequence[Any], *, metadata_prefix: str = "openviking"+) -> list[dict[str, Any]]:"""Build OpenViking ContextPart dictionaries from LangChain Documents."""parts: list[dict[str, Any]] = []for doc in documents:metadata = getattr(doc, "metadata", {}) or {}- uri = metadata.get("openviking_uri") or metadata.get("source") or ""+ uri = metadata.get(f"{metadata_prefix}_uri") or metadata.get("source") or ""if not uri:continueparts.append({"type": "context","uri": uri,- "context_type": metadata.get("openviking_context_type") or "resource",- "abstract": metadata.get("openviking_abstract")+ "context_type": metadata.get(f"{metadata_prefix}_context_type") or "resource",+ "abstract": metadata.get(f"{metadata_prefix}_abstract")or getattr(doc, "page_content", "")[:500],})diff --git a/integrations/frameworks/langchain/src/langchain_openviking/retrievers.py b/integrations/frameworks/langchain/src/langchain_openviking/retrievers.pyindex f961d01ae..3a09276be 100644--- a/integrations/frameworks/langchain/src/langchain_openviking/retrievers.py+++ b/integrations/frameworks/langchain/src/langchain_openviking/retrievers.py@@ -198,7 +198,7 @@ class OpenVikingRetriever(BaseRetriever):method,query=query,target_uri=self.target_uri,- session_id=self.session_id,+ session_id=self.session_id if method == "search" else None,limit=self.limit,score_threshold=self.score_threshold,filter=self.filter,@@ -218,7 +218,7 @@ class OpenVikingRetriever(BaseRetriever):method,query=query,target_uri=self.target_uri,- session_id=self.session_id,+ session_id=self.session_id if method == "search" else None,limit=self.limit,score_threshold=self.score_threshold,filter=self.filter,diff --git a/integrations/frameworks/langchain/tests/unit/test_langchain_async_integration.py b/integrations/frameworks/langchain/tests/unit/test_langchain_async_integration.pyindex 98698da3b..1d7904c54 100644--- a/integrations/frameworks/langchain/tests/unit/test_langchain_async_integration.py+++ b/integrations/frameworks/langchain/tests/unit/test_langchain_async_integration.py@@ -6,6 +6,7 @@ import sysimport threadingfrom typing import Any+import httpximport pytestpytest.importorskip("langchain_core")@@ -967,6 +968,61 @@ async def test_async_retriever_uses_native_client_for_search_and_read():assert set(client.call_thread_ids) == {main_thread_id}[email protected]("asynchronous", [False, True])[email protected]("search_mode", ["find", "search"])[email protected]("session_id", [None, "review-session"])+async def test_retriever_passes_session_only_to_search(+ monkeypatch, asynchronous, search_mode, session_id+):+ from openviking_sdk import AsyncHTTPClient, SyncHTTPClient++ requests = []++ async def request(self, method, path, **kwargs):+ requests.append((method, path, kwargs["json"]))+ return httpx.Response(+ 200,+ json={+ "status": "ok",+ "result": {+ "resources": [+ {"uri": "viking://resources/release.md", "abstract": "Release checklist"}+ ]+ },+ },+ )++ monkeypatch.setattr(AsyncHTTPClient, "_request", request)+ client_type = AsyncHTTPClient if asynchronous else SyncHTTPClient+ client = client_type(url="http://openviking.test", api_key="test")+ retriever = OpenVikingRetriever(+ **({"async_client": client} if asynchronous else {"client": client}),+ search_mode=search_mode,+ session_id=session_id,+ content_mode="abstract",+ score_threshold=0.5,+ tags=["env=test"],+ )+ try:+ documents = (+ await retriever.ainvoke("release") if asynchronous else retriever.invoke("release")+ )+ finally:+ await retriever.aclose()+ if asynchronous:+ await client.close()+ else:+ client.close()++ assert [document.page_content for document in documents] == ["Release checklist"]+ expected = {"query": "release", "target_uri": "", "limit": 10, "score_threshold": 0.5}+ expected["tags"] = ["env=test"]+ if search_mode == "search" and session_id is not None:+ expected["session_id"] = session_id+ assert requests == [("POST", f"/api/v1/search/{search_mode}", expected)]++@pytest.mark.asyncioasync def test_async_recorder_preserves_batch_and_commit_semantics():class BatchTrackingClient(InMemoryOpenVikingClient):@@ -1318,16 +1374,31 @@ async def test_async_chat_history_reads_writes_and_clears_natively():@pytest.mark.asyncio-async def test_async_context_assembler_combines_session_and_recall():- backing = InMemoryOpenVikingClient(- {"viking://resources/runbooks/async.md": "Async context is azure."}- )[email protected]("metadata_prefix", ["openviking", "recall", "", "my_recall"])+ "uri,context_type",+ [+ ("viking://resources/runbooks/async.md", "resource"),+ ("viking://user/default/memories/preferences/async.md", "memory"),+ ("viking://skills/async.md", "skill"),+ ],+)+async def test_async_context_assembler_combines_session_and_recall(+ metadata_prefix, uri, context_type+):+ content = "Async context is azure. " * 30+ backing = InMemoryOpenVikingClient({uri: content})backing.add_message("async-assembler", "user", content="Active async turn.")client = AsyncInMemoryOpenVikingClient(backing)assembler = OpenVikingSessionContextAssembler(include_session_context=True,async_client=client,- target_uri="viking://resources",+ retriever=OpenVikingRetriever(+ async_client=client,+ target_uri=uri,+ metadata_prefix=metadata_prefix,+ search_mode="search",+ ),)assembled = await assembler.aassemble(@@ -1337,7 +1408,23 @@ async def test_async_context_assembler_combines_session_and_recall():assert "Active async turn." in assembled.blockassert "Async context is azure." in assembled.block- assert assembled.context_parts[0]["uri"] == "viking://resources/runbooks/async.md"+ assert assembled.context_parts == [+ {"type": "context", "uri": uri, "context_type": context_type, "abstract": content[:240]}+ ]+ recorder = OpenVikingSessionRecorder(async_client=client)+ await recorder.arecord(+ "async-assembler",+ [HumanMessage(content="Deployment question"), AIMessage(content="Deployment answer")],+ context_parts=assembled.context_parts,+ )+ assert [+ part+ for message in backing.sessions["async-assembler"][-2:]+ for part in message["parts"]+ if part["type"] == "context"+ ] == assembled.context_parts+ await recorder.aclose()+ await assembler.aclose()@pytest.mark.asynciodiff --git a/integrations/frameworks/langchain/tests/unit/test_langchain_host_history.py b/integrations/frameworks/langchain/tests/unit/test_langchain_host_history.pyindex bc2c49f89..4a49c4bd8 100644--- a/integrations/frameworks/langchain/tests/unit/test_langchain_host_history.py+++ b/integrations/frameworks/langchain/tests/unit/test_langchain_host_history.py@@ -1,5 +1,6 @@"""Native host history and capture remain independent of OV archive summaries."""+from copy import deepcopyfrom types import SimpleNamespaceimport pytest@@ -9,7 +10,15 @@ pytest.importorskip("langgraph")pytest.importorskip("langchain_openviking")from langchain_core.chat_history import InMemoryChatMessageHistory-from langchain_core.messages import AIMessage, HumanMessage+from langchain_core.language_models.fake_chat_models import FakeListChatModel+from langchain_core.messages import (+ AIMessage,+ BaseMessage,+ HumanMessage,+ SystemMessage,+ convert_to_messages,+)+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholderfrom langchain_core.runnables import RunnableLambdafrom langchain_openviking import (@@ -61,6 +70,72 @@ def test_recall_assembler_does_not_read_history_by_default():assert assembler.assemble(session_id="host", query="Rust").block[email protected]("asynchronous", [False, True])[email protected]("shape", ["list", "tuple", "single", "string"])[email protected]("streaming", [False, True])+async def test_host_history_recalls_supported_current_message_inputs(+ asynchronous, shape, streaming+):+ client = NoContextClient({"viking://resources/support.md": "support reset steps"})+ previous = HumanMessage(content="Earlier question.")+ history = InMemoryChatMessageHistory(messages=[previous])+ user = HumanMessage(content="support reset")+ current = {"list": [user], "tuple": (user,), "single": user, "string": user.content}[shape]+ prompt = ChatPromptTemplate.from_messages(+ [+ ("system", "Policy.\n{openviking_context}"),+ MessagesPlaceholder(variable_name="history"),+ ("human", "{question}"),+ ]+ )+ seen = []++ def model_input(data):+ value = data["question"]+ if isinstance(value, str):+ messages = prompt.invoke(data).to_messages()+ else:+ messages = [+ *data["history"],+ *convert_to_messages([value] if isinstance(value, BaseMessage) else value),+ ]+ seen.extend(messages)+ return messages++ async with with_openviking_memory(+ RunnableLambda(model_input) | FakeListChatModel(responses=["ok"]),+ client=client,+ history_factory=lambda _: history,+ session_id="supported-input",+ input_messages_key="question",+ history_messages_key="history",+ ) as runnable:+ payload = {"ability": "not the current query", "question": current}+ if streaming and asynchronous:+ content = "".join([chunk.content async for chunk in runnable.astream(payload)])+ elif streaming:+ content = "".join(chunk.content for chunk in runnable.stream(payload))+ else:+ response = await runnable.ainvoke(payload) if asynchronous else runnable.invoke(payload)+ content = response.content++ assert content == "ok"+ assert [call["query"] for call in client.search_calls] == ["support reset"]+ assert any("support reset steps" in str(message.content) for message in seen)+ assert seen[-1].content == "support reset"+ assert history.messages[0] is previous+ assert [message.content for message in history.messages] == [+ "Earlier question.",+ "support reset",+ "ok",+ ]+ captured = client.sessions["supported-input"]+ assert [message["role"] for message in captured] == ["user", "assistant"]+ assert captured[0]["parts"] == [{"type": "text", "text": "support reset"}]+ assert any(part["type"] == "context" for part in captured[1]["parts"])++@pytest.mark.parametrize("asynchronous", [False, True])@pytest.mark.asyncioasync def test_capture_before_summary_and_deduplicate_retained_tail_after_restart(asynchronous):@@ -146,3 +221,72 @@ def test_framework_summary_persists_and_resumes_with_no_ov_context(tmp_path):captured = [m for archive in client.archives["durable-host"] for m in archive["messages"]]assert len(captured) == 8 # Four user/assistant pairs, no replayed tail or synthetic summary.assert not any("Early constraint:" in str(message) for message in captured)++[email protected]("asynchronous", [False, True])[email protected]("structured", [False, True])[email protected]("inject_context", [False, True])[email protected]("shape", ["list", "tuple", "dict", "dict_tuple"])+async def test_recall_preserves_existing_system_message(+ asynchronous, structured, inject_context, shape+):+ content = "Keep the deployment policy."+ if structured:+ content = [+ {+ "type": "text",+ "text": "Keep the deployment policy.",+ "cache_control": {"type": "ephemeral"},+ }+ ]+ system = SystemMessage(+ content=content,+ id="policy-id",+ name="policy",+ additional_kwargs={"host_field": {"keep": True}},+ response_metadata={"source": "host"},+ )+ before = deepcopy(system.model_dump())+ client = InMemoryOpenVikingClient({"viking://resources/policy.md": "Deployment uses azure."})+ seen = []++ def answer(messages):+ if isinstance(messages, dict):+ messages = messages["messages"]+ seen.extend(messages)+ return AIMessage(content="Acknowledged.")++ async with with_openviking_memory(+ RunnableLambda(answer),+ client=client,+ history_factory=lambda _: InMemoryChatMessageHistory(),+ inject_context=inject_context,+ ) as runnable:+ values = [system, HumanMessage(content="azure deployment")]+ if shape == "tuple":+ values = tuple(values)+ elif shape == "dict":+ values = {"messages": values}+ elif shape == "dict_tuple":+ values = {"messages": tuple(values)}+ original_values = deepcopy(values)+ config = {"configurable": {"session_id": "policy"}}+ if asynchronous:+ await runnable.ainvoke(values, config=config)+ else:+ runnable.invoke(values, config=config)++ observed = next(message for message in seen if isinstance(message, SystemMessage))+ assert observed.model_dump(exclude={"content"}) == system.model_dump(exclude={"content"})+ assert system.model_dump() == before+ assert values == original_values+ if not inject_context:+ assert observed.content == content+ elif structured:+ assert observed.content[:-1] == content+ assert observed.content[-1]["type"] == "text"+ assert "Deployment uses azure." in observed.content[-1]["text"]+ else:+ assert observed.content.startswith(f"{content}\n\n<openviking_context>")+ assert "Deployment uses azure." in observed.contentdiff --git a/integrations/frameworks/langchain/tests/unit/test_langchain_integration.py b/integrations/frameworks/langchain/tests/unit/test_langchain_integration.pyindex e6e6d537e..6bfa6239f 100644--- a/integrations/frameworks/langchain/tests/unit/test_langchain_integration.py+++ b/integrations/frameworks/langchain/tests/unit/test_langchain_integration.py@@ -1211,10 +1211,20 @@ def test_generic_chat_message_roles_in_recall_query(message, expected):assert get_latest_user_text([HumanMessage(content="Earlier question."), message]) == expected-def test_session_context_assembler_uses_archive_active_messages_and_recall():- client = InMemoryOpenVikingClient(- {"viking://resources/runbooks/deploy.md": "Azure deployments use OpenViking context."}- )[email protected]("metadata_prefix", ["openviking", "recall", "", "my_recall"])+ "uri, context_type",+ [+ ("viking://resources/runbooks/deploy.md", "resource"),+ ("viking://user/default/memories/preferences/deploy.md", "memory"),+ ("viking://skills/deploy.md", "skill"),+ ],+)+def test_session_context_assembler_uses_archive_active_messages_and_recall(+ metadata_prefix, uri, context_type+):+ content = "Azure deployments use OpenViking context. " * 20+ client = InMemoryOpenVikingClient({uri: content})client.add_message("assembler-session", "user", content="Earlier user turn")client.add_message("assembler-session", "assistant", content="Earlier assistant turn")client.commit_session("assembler-session", enable_working_memory=True)@@ -1223,7 +1233,9 @@ def test_session_context_assembler_uses_archive_active_messages_and_recall():assembler = OpenVikingSessionContextAssembler(include_session_context=True,client=client,- target_uri="viking://resources",+ retriever=OpenVikingRetriever(+ client=client, target_uri=uri, metadata_prefix=metadata_prefix, search_mode="search"+ ),)assembled = assembler.assemble(session_id="assembler-session", query="azure context")@@ -1233,7 +1245,23 @@ def test_session_context_assembler_uses_archive_active_messages_and_recall():assert "Active session messages" in assembled.blockassert "Active turn" in assembled.blockassert "Azure deployments" in assembled.block- assert assembled.context_parts[0]["type"] == "context"+ assert assembled.context_parts == [+ {"type": "context", "uri": uri, "context_type": context_type, "abstract": content[:240]}+ ]+ recorder = OpenVikingSessionRecorder(client=client)+ recorder.record(+ "assembler-session",+ [HumanMessage(content="Deployment question"), AIMessage(content="Deployment answer")],+ context_parts=assembled.context_parts,+ )+ assert [+ part+ for message in client.sessions["assembler-session"][-2:]+ for part in message["parts"]+ if part["type"] == "context"+ ] == assembled.context_parts+ asyncio.run(recorder.aclose())+ asyncio.run(assembler.aclose())def test_session_context_assembler_keeps_peer_id_out_of_recall():