academia-mcp 1.10.9__tar.gz → 1.11.0__tar.gz

{academia_mcp-1.10.9 → academia_mcp-1.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: academia-mcp
-Version: 1.10.9
+Version: 1.11.0
 Summary: MCP server that provides different tools to search for scientific publications
 Author-email: Ilya Gusev <phoenixilya@gmail.com>
 Project-URL: Homepage, https://github.com/IlyaGusev/academia_mcp

{academia_mcp-1.10.9 → academia_mcp-1.11.0}/academia_mcp/server.py

@@ -63,25 +63,24 @@ def find_free_port() -> int:
     raise RuntimeError("No free port in range 5000-6000 found")
 
 
-def run(
-    host: str = "0.0.0.0",
-    port: Optional[int] = None,
-    mount_path: str = "/",
+def create_server(
     streamable_http_path: str = "/mcp",
-    transport: Literal["stdio", "sse", "streamable-http"] = "streamable-http",
+    mount_path: str = "/",
+    stateless_http: bool = True,
     disable_web_search_tools: bool = False,
     disable_llm_tools: bool = False,
-) -> None:
-    configure_uvicorn_style_logging()
+    port: Optional[int] = None,
+    host: str = "0.0.0.0",
+) -> FastMCP:
     server = FastMCP(
         "Academia MCP",
-        stateless_http=True,
+        stateless_http=stateless_http,
         streamable_http_path=streamable_http_path,
         mount_path=mount_path,
     )
     logger = logging.getLogger(__name__)
 
-    server.add_tool(arxiv_search)
+    server.add_tool(arxiv_search, structured_output=True)
     server.add_tool(arxiv_download)
     server.add_tool(s2_get_citations)
     server.add_tool(s2_get_references)
@@ -140,6 +139,27 @@ def run(
 
     server.settings.port = port
     server.settings.host = host
+    return server
+
+
+def run(
+    host: str = "0.0.0.0",
+    port: Optional[int] = None,
+    mount_path: str = "/",
+    streamable_http_path: str = "/mcp",
+    transport: Literal["stdio", "sse", "streamable-http"] = "streamable-http",
+    disable_web_search_tools: bool = False,
+    disable_llm_tools: bool = False,
+) -> None:
+    configure_uvicorn_style_logging()
+    server = create_server(
+        streamable_http_path=streamable_http_path,
+        mount_path=mount_path,
+        disable_web_search_tools=disable_web_search_tools,
+        disable_llm_tools=disable_llm_tools,
+        port=port,
+        host=host,
+    )
 
     if transport == "streamable-http":
         # Enable CORS for browser-based clients

{academia_mcp-1.10.9 → academia_mcp-1.11.0}/academia_mcp/tools/arxiv_search.py

@@ -2,12 +2,12 @@
 # https://github.com/jonatasgrosman/findpapers/blob/master/findpapers/searchers/arxiv_searcher.py
 # https://info.arxiv.org/help/api/user-manual.html
 
-import json
 import re
 from typing import Optional, List, Dict, Any, Union
 from datetime import datetime, date
 
 import xmltodict
+from pydantic import BaseModel, Field
 
 from academia_mcp.utils import get_with_retries
 
@@ -17,6 +17,25 @@ SORT_BY_OPTIONS = ("relevance", "lastUpdatedDate", "submittedDate")
 SORT_ORDER_OPTIONS = ("ascending", "descending")
 
 
+class ArxivSearchEntry(BaseModel):  # type: ignore
+    id: str = Field(description="Paper ID")
+    title: str = Field(description="Paper title")
+    authors: str = Field(description="Authors of the paper")
+    published: str = Field(description="Published date of the paper")
+    updated: str = Field(description="Updated date of the paper")
+    categories: str = Field(description="Categories of the paper")
+    comment: str = Field(description="Comment of the paper")
+    index: int = Field(description="Index of the paper", default=0)
+    abstract: Optional[str] = Field(description="Abstract of the paper", default=None)
+
+
+class ArxivSearchResponse(BaseModel):  # type: ignore
+    total_count: int = Field(description="The total number of results")
+    returned_count: int = Field(description="The number of results returned")
+    offset: int = Field(description="The offset of the results")
+    results: List[ArxivSearchEntry] = Field(description="The results, search entries")
+
+
 def _format_text_field(text: str) -> str:
     return " ".join([line.strip() for line in text.split() if line.strip()])
 
@@ -48,17 +67,17 @@ def _format_date(date: str) -> str:
     return dt.strftime("%B %d, %Y")
 
 
-def _clean_entry(entry: Dict[str, Any]) -> Dict[str, Any]:
-    return {
-        "id": entry["id"].split("/")[-1],
-        "title": _format_text_field(entry["title"]),
-        "authors": _format_authors(entry["author"]),
-        "abstract": _format_text_field(entry["summary"]),
-        "published": _format_date(entry["published"]),
-        "updated": _format_date(entry["updated"]),
-        "categories": _format_categories(entry.get("category", {})),
-        "comment": _format_text_field(entry.get("arxiv:comment", {}).get("#text", "")),
-    }
+def _clean_entry(entry: Dict[str, Any]) -> ArxivSearchEntry:
+    return ArxivSearchEntry(
+        id=entry["id"].split("/")[-1],
+        title=_format_text_field(entry["title"]),
+        authors=_format_authors(entry["author"]),
+        abstract=_format_text_field(entry["summary"]),
+        published=_format_date(entry["published"]),
+        updated=_format_date(entry["updated"]),
+        categories=_format_categories(entry.get("category", {})),
+        comment=_format_text_field(entry.get("arxiv:comment", {}).get("#text", "")),
+    )
 
 
 def _convert_to_yyyymmddtttt(date_str: str) -> str:
@@ -105,22 +124,19 @@ def _format_entries(
     start_index: int,
     include_abstracts: bool,
     total_results: int,
-) -> str:
+) -> ArxivSearchResponse:
     clean_entries: List[Dict[str, Any]] = []
     for entry_num, entry in enumerate(entries):
         clean_entry = _clean_entry(entry)
         if not include_abstracts:
-            clean_entry.pop("abstract")
-        clean_entry["index"] = start_index + entry_num
+            clean_entry.abstract = None
+        clean_entry.index = start_index + entry_num
         clean_entries.append(clean_entry)
-    return json.dumps(
-        {
-            "total_count": total_results,
-            "returned_count": len(entries),
-            "offset": start_index,
-            "results": clean_entries,
-        },
-        ensure_ascii=False,
+    return ArxivSearchResponse(
+        total_count=total_results,
+        returned_count=len(entries),
+        offset=start_index,
+        results=clean_entries,
     )
 
 
@@ -133,7 +149,7 @@ def arxiv_search(
     sort_by: Optional[str] = "relevance",
     sort_order: Optional[str] = "descending",
     include_abstracts: Optional[bool] = False,
-) -> str:
+) -> ArxivSearchResponse:
     """
     Search arXiv papers with field-specific queries.
 
@@ -158,12 +174,6 @@ def arxiv_search(
         all:role OR all:playing OR all:"language model"
         (au:vaswani OR au:"del maestro") ANDNOT ti:attention
 
-    Returns a JSON object serialized to a string. The structure is:
-    {"total_count": ..., "returned_count": ..., "offset": ..., "results": [...]}
-    Every item in the "results" has the following fields:
-    ("index", "id", "title", "authors", "abstract", "published", "updated", "categories", "comment")
-    Use `json.loads` to deserialize the result if you want to get specific fields.
-
     Args:
         query: The search query, required.
         offset: The offset to scroll search results. 10 items will be skipped if offset=10. 0 by default.
@@ -211,10 +221,9 @@ def arxiv_search(
     entries = feed.get("entry", [])
     if isinstance(entries, dict):
         entries = [entries]
-    formatted_entries: str = _format_entries(
+    return _format_entries(
         entries,
         start_index=start_index,
         total_results=total_results,
         include_abstracts=include_abstracts,
     )
-    return formatted_entries

{academia_mcp-1.10.9 → academia_mcp-1.11.0}/academia_mcp/tools/show_image.py

@@ -30,7 +30,20 @@ DESCRIBE_PROMPTS = {
         4. Any immediate tactical opportunities or threats
         5. Suggested next moves with brief explanations"""
     ),
-    "text": "Extract and describe any text present in this image. If there are multiple pieces of text, organize them clearly.",
+    "text": dedent(
+        """You are performing OCR and transcription.
+        Extract ALL text and numbers from the image verbatim.
+        - Preserve original casing, punctuation, symbols, mathematical notation, and whitespace layout when possible.
+        - If layout is multi-column or tabular, reconstruct lines top-to-bottom, left-to-right; use line breaks between blocks.
+        - For any uncertain or low-confidence characters, mark with a '?' and include a note.
+        - After the raw extraction, provide a clean, normalized version (fixing obvious OCR artifacts) as a separate section.
+        Return two sections:
+        [RAW TRANSCRIPTION]
+        ...
+        [NORMALIZED]
+        ...
+        """
+    ),
 }
 
 
@@ -44,10 +57,8 @@ def show_image(path: str) -> Dict[str, str]:
     ```
     Do not print it ever, just return as the last expression.
 
-    Returns an dictionary with a single "image" key.
-
     Args:
-        url: Path to file inside current work directory or web URL
+        path: Path to file inside current work directory or web URL
     """
     if path.startswith("http"):
         response = httpx.get(path, timeout=10)
@@ -80,7 +91,7 @@ async def describe_image(
             - "general": General description of the image
             - "detailed": Detailed analysis of the image
             - "chess": Analysis of a chess position
-            - "text": Extract and describe text from the image
+            - "text": Extract and describe text or numbers from the image
             - "custom": Custom description based on user prompt
     """
     image_base64 = show_image(path)["image_base64"]
@@ -93,12 +104,16 @@ async def describe_image(
         {"type": "text", "text": prompt},
         {
             "type": "image_url",
-            "image_url": {"url": f"data:image/jpeg;base64,{image_base64}"},
+            "image_url": {"url": f"data:image/png;base64,{image_base64}"},
         },
     ]
     model_name = settings.DESCRIBE_IMAGE_MODEL_NAME
+    llm_kwargs = {}
+    if description_type in {"text", "chess"}:
+        llm_kwargs["temperature"] = 0.0
     response = await llm_acall(
         model_name=model_name,
         messages=[ChatMessage(role="user", content=content)],
+        **llm_kwargs,
     )
     return response

{academia_mcp-1.10.9 → academia_mcp-1.11.0}/academia_mcp/tools/visit_webpage.py

@@ -33,12 +33,15 @@ def _tavily_visit_webpage(url: str) -> Dict[str, Any]:
     assert key, "Error: TAVILY_API_KEY is not set and no api_key was provided"
     payload = {
         "urls": [url],
+        "extract_depth": "advanced",
+        "include_images": True,
     }
     response = post_with_retries(TAVILY_EXTRACT_URL, payload=payload, api_key=key)
     results = response.json()["results"]
     if not results:
         return {"error": ERROR_MESSAGE}
-    return {"text": results[0]["raw_content"]}
+    result = results[0]
+    return {"text": result["raw_content"], "images": result["images"]}
 
 
 def _basic_visit_webpage(url: str) -> Dict[str, Any]:

{academia_mcp-1.10.9 → academia_mcp-1.11.0}/academia_mcp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: academia-mcp
-Version: 1.10.9
+Version: 1.11.0
 Summary: MCP server that provides different tools to search for scientific publications
 Author-email: Ilya Gusev <phoenixilya@gmail.com>
 Project-URL: Homepage, https://github.com/IlyaGusev/academia_mcp

{academia_mcp-1.10.9 → academia_mcp-1.11.0}/academia_mcp.egg-info/SOURCES.txt

@@ -44,6 +44,7 @@ tests/test_hf_dataset_search.py
 tests/test_latex.py
 tests/test_review.py
 tests/test_s2.py
+tests/test_server.py
 tests/test_show_image.py
 tests/test_speech_to_text.py
 tests/test_visit_webpage.py

{academia_mcp-1.10.9 → academia_mcp-1.11.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "academia-mcp"
-version = "1.10.9"
+version = "1.11.0"
 description = "MCP server that provides different tools to search for scientific publications"
 readme = "README.md"
 authors = [

{academia_mcp-1.10.9 → academia_mcp-1.11.0}/tests/test_arxiv_search.py

@@ -5,9 +5,7 @@ from academia_mcp.tools import arxiv_search
 
 def test_arxiv_search_basic_search() -> None:
     result = arxiv_search('ti:"PingPong: A Benchmark for Role-Playing Language Models"')
-    assert isinstance(result, str)
-    assert len(result) > 0
-    assert "Ilya Gusev" in result
+    assert "Ilya Gusev" in str(result)
 
 
 def test_arxiv_search_empty_query() -> None:
@@ -50,29 +48,25 @@ def test_arxiv_search_sort_by_options() -> None:
     valid_sort_options = ["relevance", "lastUpdatedDate", "submittedDate"]
     for sort_option in valid_sort_options:
         result = arxiv_search("abs:physics", sort_by=sort_option)
-        assert isinstance(result, str)
-        assert len(result) > 0
+        assert result.total_count > 0
 
 
 def sort_order_options() -> None:
     result1 = arxiv_search("abs:physics", sort_order="ascending")
     result2 = arxiv_search("abs:physics", sort_order="descending")
-    assert isinstance(result1, str)
-    assert len(result1) > 0
-    assert isinstance(result2, str)
-    assert len(result2) > 0
+    assert result1.total_count > 0
+    assert result2.total_count > 0
     assert result1 != result2
 
 
 def test_arxiv_search_unicode_in_query() -> None:
-    result = arxiv_search('abs:"Schrödinger equation"')
-    assert isinstance(result, str)
-    assert len(result) > 0
+    result = arxiv_search("Schrödinger equation")
+    assert result.total_count > 0
 
 
 def test_arxiv_search_result_format() -> None:
     result = arxiv_search("abs:physics")
-    assert "title" in result.lower()
+    assert "title" in str(result).lower()
 
 
 def test_arxiv_search_type_validation() -> None:
@@ -93,24 +87,21 @@ def test_arxiv_search_integration_multiple_pages() -> None:
     second_page = arxiv_search("abs:physics", offset=5, limit=5)
     third_page = arxiv_search("abs:physics", offset=10, limit=5)
     assert first_page != second_page != third_page
-    assert isinstance(first_page, str)
-    assert isinstance(second_page, str)
-    assert isinstance(third_page, str)
 
 
 def test_arxiv_search_date_filter() -> None:
     result = arxiv_search("au:vaswani", start_date="2017-06-01", end_date="2017-07-01", limit=2)
-    assert "Attention Is All You Need" in result
+    assert "Attention Is All You Need" in str(result)
 
 
 def test_arxiv_search_start_date_only() -> None:
     result = arxiv_search('au:vaswani AND ti:"attention is all"', start_date="2017-06-01")
-    assert "Attention Is All You Need" in result
+    assert "Attention Is All You Need" in str(result)
 
 
 def test_arxiv_search_end_date_only() -> None:
     result = arxiv_search('au:vaswani AND ti:"attention is all"', end_date="2017-07-01")
-    assert "Attention Is All You Need" in result
+    assert "Attention Is All You Need" in str(result)
 
 
 def test_arxiv_search_complex_query_vq_vae() -> None:
@@ -121,7 +112,7 @@ def test_arxiv_search_complex_query_vq_vae() -> None:
         sort_order="ascending",
         include_abstracts=True,
     )
-    assert "1711.00937" in result
+    assert "1711.00937" in str(result)
 
 
 def test_arxiv_search_point_e() -> None:
@@ -132,4 +123,4 @@ def test_arxiv_search_point_e() -> None:
         sort_order="ascending",
         include_abstracts=True,
     )
-    assert "2212.08751" in result
+    assert "2212.08751" in str(result)

academia_mcp-1.11.0/tests/test_server.py

@@ -0,0 +1,35 @@
+from typing import Dict, Any
+
+from mcp import ClientSession
+from mcp.types import CallToolResult
+from mcp.client.streamable_http import streamablehttp_client
+
+from tests.conftest import MCPServerTest
+
+
+async def call_tool(mcp_server_test: MCPServerTest, tool: str, kwargs: Dict[str, Any]) -> Any:
+    url = f"http://{mcp_server_test.host}:{mcp_server_test.port}/mcp"
+    async with streamablehttp_client(
+        url,
+        timeout=60,
+        sse_read_timeout=60,
+    ) as (
+        read_stream,
+        write_stream,
+        _,
+    ):
+        async with ClientSession(read_stream, write_stream) as session:
+            await session.initialize()
+            result: CallToolResult = await session.call_tool(tool, kwargs)
+            return result.structuredContent
+
+
+def test_server_run(mcp_server_test: MCPServerTest) -> None:
+    assert mcp_server_test.server is not None
+    assert mcp_server_test.is_running()
+
+
+async def test_server_arxiv_search(mcp_server_test: MCPServerTest) -> None:
+    query = 'ti:"PingPong: A Benchmark for Role-Playing Language Models"'
+    result = await call_tool(mcp_server_test, "arxiv_search", {"query": query})
+    assert result["results"][0]["authors"] == "Ilya Gusev"