Merge remote-tracking branch 'origin/master' into xuhd
# Conflicts: # frontend-web/.env.production # frontend-web/.env.sit # frontend-web/package.json # offline-backend-20260512/backend/config.yaml
This commit is contained in:
commit
1668c1da87
177 files changed
+21030
-2738
No files matched your search
@@ -299,6 +299,16 @@ def _build_middlewares(
|
||||
if not is_bootstrap and not is_writing_setup:
|
||||
middlewares.append(MemoryMiddleware(agent_name=agent_name, memory_config=resolved_app_config.memory, injection_enabled=memory_injection_enabled))
|
||||
|
||||
# KnowledgeRagMiddleware — inject knowledge-base recall (phase 2). Gated
|
||||
# per-conversation by the ``knowledge_rag_enabled`` runtime flag, defaulting
|
||||
# to the global ``knowledge.rag_enabled`` config. No-op when knowledge is
|
||||
# disabled. Skipped in bootstrap/writing-setup like MemoryMiddleware.
|
||||
knowledge_cfg = getattr(resolved_app_config, "knowledge", None)
|
||||
if not is_bootstrap and not is_writing_setup and knowledge_cfg is not None and knowledge_cfg.enabled:
|
||||
from deerflow.agents.middlewares.knowledge_rag_middleware import KnowledgeRagMiddleware
|
||||
|
||||
middlewares.append(KnowledgeRagMiddleware(limit=knowledge_cfg.rag_limit, default_enabled=knowledge_cfg.rag_enabled))
|
||||
|
||||
# Add ViewImageMiddleware only for the NATIVE-vision path (main model
|
||||
# ingests raw image data). In delegated mode the view_image tool already
|
||||
# returns a text description and stores nothing in `viewed_images`, so the
|
||||
|
||||
+190
@@ -0,0 +1,190 @@
|
||||
"""KnowledgeRagMiddleware — inject knowledge-base recall before the model call.
|
||||
|
||||
Phase 2 of the product knowledge base. When enabled (per-conversation runtime
|
||||
flag ``knowledge_rag_enabled``, falling back to the global
|
||||
``knowledge.rag_enabled`` config), the latest user question is used to retrieve
|
||||
the most relevant knowledge notes, which are injected as a transient
|
||||
``<knowledge-context>`` system message — not persisted to state, so it never
|
||||
leaks to the frontend transcript.
|
||||
|
||||
Retrieval is hybrid (vector + keyword) when an embedding endpoint is
|
||||
configured, else keyword/wiki-query layered search. Failures are swallowed: RAG
|
||||
must never break a conversation.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
import logging
|
||||
from typing import Any, override
|
||||
|
||||
from langchain.agents import AgentState
|
||||
from langchain.agents.middleware import AgentMiddleware
|
||||
from langchain_core.messages import HumanMessage
|
||||
from langgraph.runtime import Runtime
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
_TAG = "knowledge-context"
|
||||
|
||||
|
||||
def _coerce_text(content: Any) -> str:
|
||||
if isinstance(content, str):
|
||||
return content
|
||||
if isinstance(content, list):
|
||||
parts = []
|
||||
for block in content:
|
||||
if isinstance(block, str):
|
||||
parts.append(block)
|
||||
elif isinstance(block, dict) and block.get("type") == "text":
|
||||
parts.append(str(block.get("text", "")))
|
||||
return " ".join(parts)
|
||||
return str(content or "")
|
||||
|
||||
|
||||
def _latest_human_text(messages: list) -> str:
|
||||
for msg in reversed(messages or []):
|
||||
if isinstance(msg, HumanMessage):
|
||||
return _coerce_text(msg.content).strip()
|
||||
return ""
|
||||
|
||||
|
||||
class KnowledgeRagMiddleware(AgentMiddleware[AgentState]):
|
||||
"""Inject knowledge-base recall as transient system context."""
|
||||
|
||||
state_schema = AgentState
|
||||
|
||||
def __init__(self, *, limit: int = 5, default_enabled: bool = False) -> None:
|
||||
super().__init__()
|
||||
self._limit = limit
|
||||
self._default_enabled = default_enabled
|
||||
self._service = None # lazy
|
||||
|
||||
def _get_service(self):
|
||||
if self._service is not None:
|
||||
return self._service
|
||||
try:
|
||||
from deerflow.config import get_app_config
|
||||
from deerflow.knowledge import make_knowledge_service
|
||||
from deerflow.persistence.engine import get_session_factory
|
||||
|
||||
config = get_app_config()
|
||||
self._service = make_knowledge_service(get_session_factory(), config.knowledge)
|
||||
except Exception:
|
||||
logger.exception("KnowledgeRagMiddleware: failed to build knowledge service")
|
||||
self._service = None
|
||||
return self._service
|
||||
|
||||
def _enabled_for(self, request: Any) -> bool:
|
||||
runtime = getattr(request, "runtime", None)
|
||||
if runtime is not None and getattr(runtime, "context", None):
|
||||
flag = runtime.context.get("knowledge_rag_enabled")
|
||||
if flag is not None:
|
||||
return bool(flag)
|
||||
return self._default_enabled
|
||||
|
||||
async def _build_context_message(self, request: Any) -> HumanMessage | None:
|
||||
if not self._enabled_for(request):
|
||||
return None
|
||||
service = self._get_service()
|
||||
if service is None:
|
||||
return None
|
||||
query = _latest_human_text(getattr(request, "messages", None) or [])
|
||||
if not query:
|
||||
return None
|
||||
try:
|
||||
result = await service.build_rag_context(query, limit=self._limit)
|
||||
except Exception:
|
||||
logger.exception("KnowledgeRagMiddleware: recall failed (non-fatal)")
|
||||
return None
|
||||
text = result.get("text") if isinstance(result, dict) else ""
|
||||
if not text:
|
||||
return None
|
||||
fenced = (
|
||||
f"<{_TAG}>\n"
|
||||
"[系统提示:以下是知识库召回的背景资料,不是用户的新输入。回答时优先参考,"
|
||||
"并在使用到时标注来源 note_id。]\n\n"
|
||||
f"{text}\n"
|
||||
f"</{_TAG}>"
|
||||
)
|
||||
return HumanMessage(content=fenced)
|
||||
|
||||
@override
|
||||
async def awrap_model_call(self, request: Any, handler: Any) -> Any:
|
||||
msg = await self._build_context_message(request)
|
||||
if msg is not None:
|
||||
request = request.override(messages=[*request.messages, msg])
|
||||
return await handler(request)
|
||||
|
||||
@override
|
||||
def wrap_model_call(self, request: Any, handler: Any) -> Any:
|
||||
# Sync path: best-effort. The gateway runtime is async, so this is rarely
|
||||
# hit; run the async recall in a private loop when there is none.
|
||||
if not self._enabled_for(request):
|
||||
return handler(request)
|
||||
try:
|
||||
loop = asyncio.get_event_loop()
|
||||
if loop.is_running():
|
||||
# Cannot block a running loop from sync code; skip injection.
|
||||
return handler(request)
|
||||
msg = loop.run_until_complete(self._build_context_message(request))
|
||||
except Exception:
|
||||
msg = None
|
||||
if msg is not None:
|
||||
request = request.override(messages=[*request.messages, msg])
|
||||
return handler(request)
|
||||
|
||||
# ---- after_agent: enqueue background auto-sedimentation -------------
|
||||
def _resolve_thread_id(self, runtime: Runtime | None) -> str | None:
|
||||
if runtime is not None and getattr(runtime, "context", None):
|
||||
tid = runtime.context.get("thread_id")
|
||||
if tid:
|
||||
return str(tid)
|
||||
try:
|
||||
from langgraph.config import get_config
|
||||
|
||||
return get_config().get("configurable", {}).get("thread_id")
|
||||
except Exception:
|
||||
return None
|
||||
|
||||
@override
|
||||
def after_agent(self, state: AgentState, runtime: Runtime) -> dict | None:
|
||||
"""When auto-ingest is on, hand the finished turn to the background queue."""
|
||||
try:
|
||||
from deerflow.config import get_app_config
|
||||
|
||||
knowledge_cfg = getattr(get_app_config(), "knowledge", None)
|
||||
if knowledge_cfg is None or not knowledge_cfg.enabled or not knowledge_cfg.auto_ingest_enabled:
|
||||
return None
|
||||
|
||||
from deerflow.knowledge.auto_ingest import AutoIngestItem, get_auto_ingest_queue
|
||||
|
||||
queue = get_auto_ingest_queue()
|
||||
if queue is None:
|
||||
return None
|
||||
|
||||
messages = state.get("messages") if isinstance(state, dict) else getattr(state, "messages", None)
|
||||
if not messages:
|
||||
return None
|
||||
|
||||
from deerflow.runtime.references import build_reference_batches
|
||||
from deerflow.runtime.serialization import serialize_lc_object
|
||||
from deerflow.runtime.user_context import get_effective_user_id
|
||||
|
||||
serialized = [serialize_lc_object(m) for m in messages]
|
||||
thread_id = self._resolve_thread_id(runtime)
|
||||
if not thread_id:
|
||||
return None
|
||||
title = state.get("title") if isinstance(state, dict) else getattr(state, "title", None)
|
||||
queue.enqueue(
|
||||
AutoIngestItem(
|
||||
thread_id=thread_id,
|
||||
user_id=get_effective_user_id(),
|
||||
messages=serialized,
|
||||
thread_title=title if isinstance(title, str) else None,
|
||||
reference_batches=build_reference_batches(serialized),
|
||||
)
|
||||
)
|
||||
except Exception:
|
||||
logger.exception("KnowledgeRagMiddleware.after_agent enqueue failed (non-fatal)")
|
||||
return None
|
||||
Reference in new issue
Block a user