deepresearch-flow 0.7.1__tar.gz → 0.7.3__tar.gz

{deepresearch_flow-0.7.1/python/deepresearch_flow.egg-info → deepresearch_flow-0.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepresearch-flow
-Version: 0.7.1
+Version: 0.7.3
 Summary: Workflow tools for paper extraction, review, and research automation.
 Author-email: DengQi <dengqi935@gmail.com>
 License: MIT License
@@ -532,6 +532,22 @@ server {
     proxy_set_header X-Real-IP $remote_addr;
     proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
   }
+
+  # SSE transport for MCP clients that require Server-Sent Events
+  location ^~ /mcp-sse {
+    proxy_pass http://127.0.0.1:8001;
+    proxy_http_version 1.1;
+    proxy_set_header Connection "";
+    proxy_set_header Host $host;
+    proxy_set_header X-Real-IP $remote_addr;
+    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+    proxy_buffering off;
+    proxy_cache off;
+    proxy_read_timeout 3600s;
+    proxy_send_timeout 3600s;
+    chunked_transfer_encoding off;
+    add_header X-Accel-Buffering no;
+  }
 }
 
 # Static assets (separate domain)
@@ -562,12 +578,15 @@ uv run deepresearch-flow paper db api serve \
   --host 0.0.0.0 --port 8001
 ```
 
-### 3.1) MCP (FastMCP Streamable HTTP)
+### 3.1) MCP (FastMCP Streamable HTTP + SSE)
 
-This project exposes an MCP server mounted at `/mcp` on the snapshot API:
+This project exposes MCP servers mounted on the snapshot API:
 
-- Endpoint: `http://<host>:8001/mcp` (same host/port as `paper db api serve`)
-- Transport: Streamable HTTP via `POST` only (no SSE; `GET` returns 405)
+- Streamable HTTP endpoint: `http://<host>:8001/mcp`
+- SSE endpoint: `http://<host>:8001/mcp-sse`
+- Transport behavior:
+  - `/mcp`: Streamable HTTP via `POST` only (`GET` returns 405)
+  - `/mcp-sse`: SSE-enabled transport (supports `GET` handshake)
 - Protocol header: optional `mcp-protocol-version` (`2025-03-26` or `2025-06-18`)
 - Static reads: summary/source/translation are served as **text content** by reading snapshot static assets (local-first via `PAPER_DB_STATIC_EXPORT_DIR`, HTTP fallback via `PAPER_DB_STATIC_BASE` / `PAPER_DB_STATIC_BASE_URL`)
 
@@ -959,7 +978,7 @@ docker run --rm -p 8899:8899 \
 ```
 
 Notes:
-- nginx listens on 8899 and proxies `/api` and `/mcp` to the internal API at `127.0.0.1:8000`.
+- nginx listens on 8899 and proxies `/api`, `/mcp`, and `/mcp-sse` to the internal API at `127.0.0.1:8000`.
 - Mount your snapshot DB to `/db/papers.db` inside the container.
 - Mount snapshot static assets to `/static` when serving assets from this container (default `PAPER_DB_STATIC_BASE` is `/static`).
 - If `PAPER_DB_STATIC_BASE` is a full URL (e.g. `https://static.example.com`), nginx still serves the frontend locally, while API responses use that external static base for asset links.

{deepresearch_flow-0.7.1 → deepresearch_flow-0.7.3}/README.md

@@ -469,6 +469,22 @@ server {
     proxy_set_header X-Real-IP $remote_addr;
     proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
   }
+
+  # SSE transport for MCP clients that require Server-Sent Events
+  location ^~ /mcp-sse {
+    proxy_pass http://127.0.0.1:8001;
+    proxy_http_version 1.1;
+    proxy_set_header Connection "";
+    proxy_set_header Host $host;
+    proxy_set_header X-Real-IP $remote_addr;
+    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+    proxy_buffering off;
+    proxy_cache off;
+    proxy_read_timeout 3600s;
+    proxy_send_timeout 3600s;
+    chunked_transfer_encoding off;
+    add_header X-Accel-Buffering no;
+  }
 }
 
 # Static assets (separate domain)
@@ -499,12 +515,15 @@ uv run deepresearch-flow paper db api serve \
   --host 0.0.0.0 --port 8001
 ```
 
-### 3.1) MCP (FastMCP Streamable HTTP)
+### 3.1) MCP (FastMCP Streamable HTTP + SSE)
 
-This project exposes an MCP server mounted at `/mcp` on the snapshot API:
+This project exposes MCP servers mounted on the snapshot API:
 
-- Endpoint: `http://<host>:8001/mcp` (same host/port as `paper db api serve`)
-- Transport: Streamable HTTP via `POST` only (no SSE; `GET` returns 405)
+- Streamable HTTP endpoint: `http://<host>:8001/mcp`
+- SSE endpoint: `http://<host>:8001/mcp-sse`
+- Transport behavior:
+  - `/mcp`: Streamable HTTP via `POST` only (`GET` returns 405)
+  - `/mcp-sse`: SSE-enabled transport (supports `GET` handshake)
 - Protocol header: optional `mcp-protocol-version` (`2025-03-26` or `2025-06-18`)
 - Static reads: summary/source/translation are served as **text content** by reading snapshot static assets (local-first via `PAPER_DB_STATIC_EXPORT_DIR`, HTTP fallback via `PAPER_DB_STATIC_BASE` / `PAPER_DB_STATIC_BASE_URL`)
 
@@ -896,7 +915,7 @@ docker run --rm -p 8899:8899 \
 ```
 
 Notes:
-- nginx listens on 8899 and proxies `/api` and `/mcp` to the internal API at `127.0.0.1:8000`.
+- nginx listens on 8899 and proxies `/api`, `/mcp`, and `/mcp-sse` to the internal API at `127.0.0.1:8000`.
 - Mount your snapshot DB to `/db/papers.db` inside the container.
 - Mount snapshot static assets to `/static` when serving assets from this container (default `PAPER_DB_STATIC_BASE` is `/static`).
 - If `PAPER_DB_STATIC_BASE` is a full URL (e.g. `https://static.example.com`), nginx still serves the frontend locally, while API responses use that external static base for asset links.

{deepresearch_flow-0.7.1 → deepresearch_flow-0.7.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "deepresearch-flow"
-version = "0.7.1"
+version = "0.7.3"
 description = "Workflow tools for paper extraction, review, and research automation."
 readme = { file = "README.md", content-type = "text/markdown" }
 license = { file = "LICENSE" }

{deepresearch_flow-0.7.1 → deepresearch_flow-0.7.3}/python/deepresearch_flow/paper/snapshot/api.py

@@ -908,7 +908,7 @@ def create_app(
     # Lazy import to avoid circular dependency
     from deepresearch_flow.paper.snapshot.mcp_server import (
         McpSnapshotConfig,
-        create_mcp_app,
+        create_mcp_apps,
         resolve_static_export_dir,
     )
 
@@ -919,7 +919,7 @@ def create_app(
         limits=limits or ApiLimits(),
         origin_allowlist=cors_allowed_origins or ["*"],
     )
-    mcp_app, mcp_lifespan = create_mcp_app(mcp_config)
+    mcp_apps, mcp_lifespan = create_mcp_apps(mcp_config)
 
     routes = [
         Route("/api/v1/config", _api_config, methods=["GET"]),
@@ -931,7 +931,8 @@ def create_app(
         Route("/api/v1/facets/{facet:str}/{facet_id:str}/stats", _api_facet_stats, methods=["GET"]),
         Route("/api/v1/facets/{facet:str}/by-value/{value:str}/papers", _api_facet_by_value_papers, methods=["GET"]),
         Route("/api/v1/facets/{facet:str}/by-value/{value:str}/stats", _api_facet_by_value_stats, methods=["GET"]),
-        Mount("/mcp", app=mcp_app),
+        Mount("/mcp", app=mcp_apps["streamable-http"]),
+        Mount("/mcp-sse", app=mcp_apps["sse"]),
     ]
 
     # Pass MCP lifespan to ensure session manager initializes properly

{deepresearch_flow-0.7.1 → deepresearch_flow-0.7.3}/python/deepresearch_flow/paper/snapshot/mcp_server.py

@@ -5,7 +5,7 @@ import json
 import os
 from pathlib import Path
 import re
-from typing import Any
+from typing import Any, Literal
 
 import httpx
 from starlette.applications import Starlette
@@ -76,14 +76,13 @@ class McpSnapshotConfig:
 
 
 class McpRequestGuardMiddleware(BaseHTTPMiddleware):
-    def __init__(self, app, *, origin_allowlist: list[str]) -> None:
+    def __init__(self, app, *, origin_allowlist: list[str], allowed_methods: set[str] | None = None) -> None:
         super().__init__(app)
         self._allowlist = [origin.lower() for origin in origin_allowlist]
+        self._allowed_methods = {method.upper() for method in (allowed_methods or {"POST", "OPTIONS"})}
 
     async def dispatch(self, request: Request, call_next):  # type: ignore[override]
-        if request.method == "GET":
-            return Response("Method Not Allowed", status_code=405)
-        if request.method not in {"POST", "OPTIONS"}:
+        if request.method.upper() not in self._allowed_methods:
             return Response("Method Not Allowed", status_code=405)
         origin = request.headers.get("origin")
         if origin and not self._is_allowed_origin(origin):
@@ -108,23 +107,49 @@ def configure(config: McpSnapshotConfig) -> None:
     _CONFIG = config
 
 
-def create_mcp_app(config: McpSnapshotConfig) -> tuple[Starlette, Any]:
-    """Create MCP app with middleware and return it along with lifespan.
-    
-    Returns:
-        Tuple of (wrapped_app, lifespan_context) for use by parent Starlette.
-    """
+def _allowed_methods_for_transport(transport: Literal["streamable-http", "sse"]) -> set[str]:
+    if transport == "sse":
+        return {"GET", "POST", "OPTIONS"}
+    return {"POST", "OPTIONS"}
+
+
+def create_mcp_transport_app(
+    config: McpSnapshotConfig,
+    *,
+    transport: Literal["streamable-http", "sse"] = "streamable-http",
+) -> tuple[Starlette, Any]:
+    """Create MCP app for a specific transport with transport-aware method guard."""
     configure(config)
-    mcp_app = mcp.http_app(path="/", stateless_http=True)
+    mcp_app = mcp.http_app(path="/", transport=transport, stateless_http=(transport == "streamable-http"))
     wrapped = Starlette(
         routes=[Mount("/", app=mcp_app)],
         middleware=[
-            Middleware(McpRequestGuardMiddleware, origin_allowlist=config.origin_allowlist),
+            Middleware(
+                McpRequestGuardMiddleware,
+                origin_allowlist=config.origin_allowlist,
+                allowed_methods=_allowed_methods_for_transport(transport),
+            ),
         ],
     )
     return wrapped, mcp_app.lifespan
 
 
+def create_mcp_apps(config: McpSnapshotConfig) -> tuple[dict[str, Starlette], Any]:
+    """Create streamable-http and sse MCP apps.
+
+    Returns:
+        A tuple of (apps_by_transport, lifespan_context).
+    """
+    streamable_app, lifespan = create_mcp_transport_app(config, transport="streamable-http")
+    sse_app, _ = create_mcp_transport_app(config, transport="sse")
+    return {"streamable-http": streamable_app, "sse": sse_app}, lifespan
+
+
+def create_mcp_app(config: McpSnapshotConfig) -> tuple[Starlette, Any]:
+    """Backward-compatible helper returning streamable-http MCP app."""
+    return create_mcp_transport_app(config, transport="streamable-http")
+
+
 def _get_config() -> McpSnapshotConfig:
     if _CONFIG is None:
         raise RuntimeError("MCP server not configured")
@@ -227,18 +252,24 @@ def _load_summary_json(paper_id: str, template: str | None) -> tuple[str | None,
     conn = _open_ro_conn(cfg.snapshot_db)
     try:
         row = conn.execute(
-            "SELECT preferred_summary_template, summary_asset_paths_json FROM paper WHERE paper_id = ?",
+            "SELECT preferred_summary_template FROM paper WHERE paper_id = ?",
             (paper_id,),
         ).fetchone()
         if not row:
             return None, None
-        preferred = row["preferred_summary_template"]
-        asset_paths = json.loads(row["summary_asset_paths_json"] or "{}")
-        available = sorted(asset_paths.keys())
-        selected = template if template else preferred
-        if not selected or selected not in asset_paths:
+        preferred = str(row["preferred_summary_template"] or "")
+        template_rows = conn.execute(
+            "SELECT template_tag FROM paper_summary WHERE paper_id = ?",
+            (paper_id,),
+        ).fetchall()
+        available = sorted((str(item["template_tag"]) for item in template_rows), key=str.lower)
+        selected = (template or preferred).strip()
+        if not selected or selected not in set(available):
             return None, available
-        rel_path = asset_paths[selected]
+        if template:
+            rel_path = f"summary/{paper_id}/{selected}.json"
+        else:
+            rel_path = f"summary/{paper_id}.json"
         return _load_static_text(rel_path), available
     finally:
         conn.close()
@@ -267,15 +298,12 @@ def _load_translation_markdown(paper_id: str, lang: str) -> str | None:
     conn = _open_ro_conn(cfg.snapshot_db)
     try:
         row = conn.execute(
-            "SELECT translations_json FROM paper WHERE paper_id = ?",
-            (paper_id,),
+            "SELECT md_content_hash FROM paper_translation WHERE paper_id = ? AND lang = ?",
+            (paper_id, lang),
         ).fetchone()
-        if not row or not row["translations_json"]:
-            return None
-        translations = json.loads(row["translations_json"])
-        rel_path = translations.get(lang)
-        if not rel_path:
+        if not row or not row["md_content_hash"]:
             return None
+        rel_path = f"md_translate/{lang}/{row['md_content_hash']}.md"
         return _load_static_text(rel_path)
     finally:
         conn.close()
@@ -296,22 +324,32 @@ def search_papers(query: str, limit: int = 10) -> list[dict[str, Any]]:
     
     conn = _open_ro_conn(cfg.snapshot_db)
     try:
+        match_expr = rewrite_search_query(query)
+        if not match_expr:
+            return []
         cur = conn.execute(
             """
-            SELECT paper_id, title, year, venue, abstract
-            FROM paper_search
-            WHERE paper_search MATCH ?
+            SELECT
+              p.paper_id,
+              p.title,
+              p.year,
+              p.venue,
+              snippet(paper_fts, -1, '[[[', ']]]', '…', 30) AS snippet_markdown,
+              bm25(paper_fts, 5.0, 3.0, 1.0, 1.0, 2.0) AS rank
+            FROM paper_fts
+            JOIN paper p ON p.paper_id = paper_fts.paper_id
+            WHERE paper_fts MATCH ?
             ORDER BY rank
             LIMIT ?
             """,
-            (rewrite_search_query(query), limit),
+            (match_expr, limit),
         )
         rows = cur.fetchall()
         results: list[dict[str, Any]] = []
         for row in rows:
-            snippet = str(row["abstract"] or "")
+            snippet = str(row["snippet_markdown"] or "")
             snippet = remove_cjk_spaces(snippet)
-            snippet, markers = merge_adjacent_markers(snippet)
+            snippet = merge_adjacent_markers(snippet)
             results.append({
                 "paper_id": str(row["paper_id"]),
                 "title": str(row["title"]),
@@ -337,7 +375,7 @@ def search_papers_by_keyword(keyword: str, limit: int = 10) -> list[dict[str, An
     try:
         rows = conn.execute(
             """
-            SELECT DISTINCT p.paper_id, p.title, p.year, p.venue, p.abstract
+            SELECT DISTINCT p.paper_id, p.title, p.year, p.venue, p.summary_preview
             FROM paper p
             JOIN paper_keyword pk ON pk.paper_id = p.paper_id
             JOIN keyword k ON k.keyword_id = pk.keyword_id
@@ -349,9 +387,9 @@ def search_papers_by_keyword(keyword: str, limit: int = 10) -> list[dict[str, An
         ).fetchall()
         results: list[dict[str, Any]] = []
         for row in rows:
-            snippet = str(row["abstract"] or "")
+            snippet = str(row["summary_preview"] or "")
             snippet = remove_cjk_spaces(snippet)
-            snippet, markers = merge_adjacent_markers(snippet)
+            snippet = merge_adjacent_markers(snippet)
             results.append({
                 "paper_id": str(row["paper_id"]),
                 "title": str(row["title"]),
@@ -377,26 +415,27 @@ def get_paper_metadata(paper_id: str) -> dict[str, Any]:
     try:
         row = conn.execute(
             """
-            SELECT paper_id, title, year, venue, doi, arxiv_id, openreview_id, paper_pw_url,
-                   preferred_summary_template, summary_asset_paths_json
+            SELECT paper_id, title, year, venue, preferred_summary_template
             FROM paper WHERE paper_id = ?
             """,
             (paper_id,),
         ).fetchone()
         if not row:
             raise McpToolError("not_found", "paper not found", paper_id=paper_id)
-        
-        asset_paths = json.loads(row["summary_asset_paths_json"] or "{}")
-        available = sorted(asset_paths.keys())
+        template_rows = conn.execute(
+            "SELECT template_tag FROM paper_summary WHERE paper_id = ?",
+            (paper_id,),
+        ).fetchall()
+        available = sorted((str(item["template_tag"]) for item in template_rows), key=str.lower)
         return {
             "paper_id": str(row["paper_id"]),
             "title": str(row["title"]),
             "year": str(row["year"]),
             "venue": str(row["venue"]),
-            "doi": row["doi"],
-            "arxiv_id": row["arxiv_id"],
-            "openreview_id": row["openreview_id"],
-            "paper_pw_url": row["paper_pw_url"],
+            "doi": None,
+            "arxiv_id": None,
+            "openreview_id": None,
+            "paper_pw_url": None,
             "preferred_summary_template": row["preferred_summary_template"],
             "available_summary_templates": available,
         }

deepresearch_flow-0.7.3/python/deepresearch_flow/paper/snapshot/tests/test_mcp_server_schema_compat.py

@@ -0,0 +1,184 @@
+from __future__ import annotations
+
+import sqlite3
+import tempfile
+from pathlib import Path
+import unittest
+
+from deepresearch_flow.paper.snapshot.common import ApiLimits
+from deepresearch_flow.paper.snapshot.mcp_server import (
+    McpSnapshotConfig,
+    McpToolError,
+    configure,
+    get_paper_metadata,
+    get_paper_source,
+    get_paper_summary,
+    resource_translation,
+    search_papers,
+    search_papers_by_keyword,
+)
+from deepresearch_flow.paper.snapshot.schema import init_snapshot_db
+
+
+class TestMcpServerSchemaCompat(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls) -> None:
+        cls.tmpdir = tempfile.TemporaryDirectory()
+        root = Path(cls.tmpdir.name)
+        cls.db_path = root / "snapshot.db"
+        cls.static_dir = root / "static"
+        cls.paper_id = "eb87c02de5b908dff9f91edda47364a5"
+
+        (cls.static_dir / "summary" / cls.paper_id).mkdir(parents=True, exist_ok=True)
+        (cls.static_dir / "md").mkdir(parents=True, exist_ok=True)
+        (cls.static_dir / "md_translate" / "zh").mkdir(parents=True, exist_ok=True)
+        (cls.static_dir / "summary" / f"{cls.paper_id}.json").write_text(
+            '{"template_tag":"deep_read","summary":"default summary"}',
+            encoding="utf-8",
+        )
+        (cls.static_dir / "summary" / cls.paper_id / "deep_read.json").write_text(
+            '{"template_tag":"deep_read","summary":"deep summary"}',
+            encoding="utf-8",
+        )
+        (cls.static_dir / "summary" / cls.paper_id / "simple.json").write_text(
+            '{"template_tag":"simple","summary":"simple summary"}',
+            encoding="utf-8",
+        )
+        (cls.static_dir / "md" / "sourcehash.md").write_text(
+            "# source body",
+            encoding="utf-8",
+        )
+        (cls.static_dir / "md_translate" / "zh" / "trhash.md").write_text(
+            "# 翻译内容",
+            encoding="utf-8",
+        )
+
+        conn = sqlite3.connect(str(cls.db_path))
+        try:
+            init_snapshot_db(conn)
+            conn.execute(
+                """
+                INSERT INTO paper(
+                  paper_id, paper_key, paper_key_type, title, year, month, publication_date,
+                  venue, preferred_summary_template, summary_preview, paper_index, source_hash,
+                  output_language, provider, model, prompt_template, extracted_at,
+                  pdf_content_hash, source_md_content_hash
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    cls.paper_id,
+                    "meta:key",
+                    "meta",
+                    "Graph Neural Networks",
+                    "2024",
+                    "01",
+                    "2024-01-01",
+                    "ICLR",
+                    "deep_read",
+                    "Graph methods preview",
+                    1,
+                    "sourcekey",
+                    "en",
+                    "provider-x",
+                    "model-y",
+                    "deep_read",
+                    "2025-01-01T00:00:00Z",
+                    "pdfhash",
+                    "sourcehash",
+                ),
+            )
+            conn.execute(
+                "INSERT INTO paper_summary(paper_id, template_tag) VALUES (?, ?)",
+                (cls.paper_id, "deep_read"),
+            )
+            conn.execute(
+                "INSERT INTO paper_summary(paper_id, template_tag) VALUES (?, ?)",
+                (cls.paper_id, "simple"),
+            )
+            conn.execute(
+                "INSERT INTO paper_translation(paper_id, lang, md_content_hash) VALUES (?, ?, ?)",
+                (cls.paper_id, "zh", "trhash"),
+            )
+            conn.execute("INSERT INTO keyword(value) VALUES (?)", ("machine learning",))
+            keyword_row = conn.execute(
+                "SELECT keyword_id FROM keyword WHERE value = ?",
+                ("machine learning",),
+            ).fetchone()
+            conn.execute(
+                "INSERT INTO paper_keyword(paper_id, keyword_id) VALUES (?, ?)",
+                (cls.paper_id, int(keyword_row[0])),
+            )
+            conn.execute(
+                """
+                INSERT INTO paper_fts(paper_id, title, summary, source, translated, metadata)
+                VALUES (?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    cls.paper_id,
+                    "graph neural networks",
+                    "graph representation learning",
+                    "source text",
+                    "translated text",
+                    "machine learning iclr",
+                ),
+            )
+            conn.commit()
+        finally:
+            conn.close()
+
+        configure(
+            McpSnapshotConfig(
+                snapshot_db=cls.db_path,
+                static_base_url="",
+                static_export_dir=cls.static_dir,
+                limits=ApiLimits(),
+                origin_allowlist=["*"],
+            )
+        )
+
+    @classmethod
+    def tearDownClass(cls) -> None:
+        cls.tmpdir.cleanup()
+
+    def test_get_paper_metadata_with_new_schema(self) -> None:
+        payload = get_paper_metadata(self.paper_id)
+        self.assertEqual(payload["paper_id"], self.paper_id)
+        self.assertEqual(payload["preferred_summary_template"], "deep_read")
+        self.assertEqual(payload["available_summary_templates"], ["deep_read", "simple"])
+        self.assertIsNone(payload["doi"])
+        self.assertIsNone(payload["arxiv_id"])
+        self.assertIsNone(payload["openreview_id"])
+        self.assertIsNone(payload["paper_pw_url"])
+
+    def test_get_paper_summary_default_and_template(self) -> None:
+        default_summary = get_paper_summary(self.paper_id)
+        deep_read_summary = get_paper_summary(self.paper_id, template="deep_read")
+        self.assertIn("default summary", default_summary)
+        self.assertIn("deep summary", deep_read_summary)
+
+    def test_get_paper_summary_template_not_available(self) -> None:
+        with self.assertRaises(McpToolError) as ctx:
+            get_paper_summary(self.paper_id, template="unknown")
+        self.assertEqual(ctx.exception.code, "template_not_available")
+        self.assertEqual(
+            ctx.exception.details["available_summary_templates"],
+            ["deep_read", "simple"],
+        )
+
+    def test_source_and_translation_loading(self) -> None:
+        source = get_paper_source(self.paper_id)
+        translated = resource_translation(self.paper_id, "zh")
+        self.assertIn("source body", source)
+        self.assertIn("翻译内容", translated)
+
+    def test_search_tools_use_current_schema(self) -> None:
+        fts_hits = search_papers("graph", limit=5)
+        facet_hits = search_papers_by_keyword("machine", limit=5)
+        self.assertGreaterEqual(len(fts_hits), 1)
+        self.assertGreaterEqual(len(facet_hits), 1)
+        self.assertEqual(fts_hits[0]["paper_id"], self.paper_id)
+        self.assertEqual(facet_hits[0]["paper_id"], self.paper_id)
+
+
+if __name__ == "__main__":
+    unittest.main()

deepresearch_flow-0.7.3/python/deepresearch_flow/paper/snapshot/tests/test_mcp_transport.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+import tempfile
+from pathlib import Path
+import unittest
+
+from deepresearch_flow.paper.snapshot.api import create_app
+from deepresearch_flow.paper.snapshot.common import ApiLimits
+from deepresearch_flow.paper.snapshot.mcp_server import (
+    McpSnapshotConfig,
+    _allowed_methods_for_transport,
+)
+
+
+class TestMcpTransport(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls) -> None:
+        cls.tmpdir = tempfile.TemporaryDirectory()
+        cls.snapshot_db = Path(cls.tmpdir.name) / "snapshot.db"
+        cls.snapshot_db.touch()
+        cls.cfg = McpSnapshotConfig(
+            snapshot_db=cls.snapshot_db,
+            static_base_url="",
+            static_export_dir=None,
+            limits=ApiLimits(),
+            origin_allowlist=["*"],
+        )
+
+    @classmethod
+    def tearDownClass(cls) -> None:
+        cls.tmpdir.cleanup()
+
+    def test_streamable_transport_rejects_get(self) -> None:
+        self.assertNotIn("GET", _allowed_methods_for_transport("streamable-http"))
+
+    def test_sse_transport_allows_get(self) -> None:
+        self.assertIn("GET", _allowed_methods_for_transport("sse"))
+
+    def test_api_mounts_streamable_and_sse_endpoints(self) -> None:
+        app = create_app(
+            snapshot_db=self.snapshot_db,
+            static_base_url="",
+            cors_allowed_origins=["*"],
+            limits=ApiLimits(),
+        )
+        mount_paths = sorted(getattr(route, "path", "") for route in app.routes)
+        self.assertIn("/mcp", mount_paths)
+        self.assertIn("/mcp-sse", mount_paths)
+
+
+if __name__ == "__main__":
+    unittest.main()