Skip to content

Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.

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.py
index 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 | Non
if isinstance(input_value, str):
return input_value
if 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 | Non
def _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 updated
updated = dict(input_value)
updated["openviking_context"] = context_block
@@ -951,8 +960,12 @@ def _merge_system_message(messages: Sequence[Any], context_block: str) -> list[A
updated = 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 updated
return [SystemMessage(content=context_block), *updated]
diff --git a/integrations/frameworks/langchain/src/langchain_openviking/history.py b/integrations/frameworks/langchain/src/langchain_openviking/history.py
index 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:
continue
parts.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.py
index 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.py
index 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 sys
import threading
from typing import Any
+import httpx
import pytest
pytest.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.asyncio
async 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.block
assert "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.asyncio
diff --git a/integrations/frameworks/langchain/tests/unit/test_langchain_host_history.py b/integrations/frameworks/langchain/tests/unit/test_langchain_host_history.py
index 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 deepcopy
from types import SimpleNamespace
import 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, MessagesPlaceholder
from langchain_core.runnables import RunnableLambda
from 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.asyncio
async 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.content
diff --git a/integrations/frameworks/langchain/tests/unit/test_langchain_integration.py b/integrations/frameworks/langchain/tests/unit/test_langchain_integration.py
index 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.block
assert "Active turn" in assembled.block
assert "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():