Tool suggestion: BGPT structured scientific evidence API

[connerlambden]

Hi, suggesting BGPT as a potential ToolUniverse integration candidate for scientific literature evidence retrieval.

BGPT is a REST, Python, and MCP API that searches scientific papers and returns structured evidence fields for each study, rather than only titles or abstracts.

Links:

• Docs: https://bgpt.pro/mcp/
• GitHub: https://github.com/connerlambden/bgpt-mcp
• OpenAPI: https://raw.githubusercontent.com/connerlambden/bgpt-mcp/main/openapi.yaml
• Postman workspace: https://www.postman.com/connerlambden-5212589/bgpt-scientific-paper-search-api/overview

Why it may fit ToolUniverse:

• It is tool-callable through standard HTTP/JSON, OpenAPI, Python examples, Postman, and MCP.
• It returns fields useful for AI scientist workflows: methods, sample sizes, study context, results, limitations, conflicts of interest, data/code availability, quality scores, blind spots, and how_to_falsify.
• It could support literature review, biomedical claim interrogation, evidence-dashboard generation, and hypothesis critique workflows.

Example behavior:

• Query: GLP-1 alcohol craving
• Returned evidence includes a small N=20 non-randomized pilot, BrAC/craving outcomes, data availability, study limitations, and the kind of larger randomized trial that would falsify the mechanism.

This seems complementary to a tool ecosystem where scientific agents need to select evidence sources and reason about study quality before proposing conclusions.

[connerlambden]

Adding one concrete implementation sketch in case it helps evaluate fit. Based on ToolUniverse's current BaseTool / @register_tool pattern, BGPT can be wrapped as a small POST-based literature evidence tool:

import requests
from typing import Any, Dict
from .base_tool import BaseTool
from .tool_registry import register_tool

@register_tool("BGPTPaperEvidenceTool")
class BGPTPaperEvidenceTool(BaseTool):
    def __init__(self, tool_config):
        super().__init__(tool_config)
        self.endpoint = "https://bgpt.pro/api/mcp-search"
        self.timeout = 45

    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
        query = arguments.get("query") or arguments.get("search_keywords")
        if not query or not str(query).strip():
            return {"status": "error", "error": "`query` is required."}

        payload = {
            "query": query,
            "num_results": int(arguments.get("num_results", arguments.get("limit", 10))),
        }
        if arguments.get("days_back") is not None:
            payload["days_back"] = int(arguments["days_back"])
        if arguments.get("api_key"):
            payload["api_key"] = arguments["api_key"]

        response = requests.post(self.endpoint, json=payload, timeout=self.timeout)
        if response.status_code != 200:
            return {
                "status": "error",
                "error": "BGPT API error",
                "status_code": response.status_code,
                "detail": response.text[:500],
            }
        return {"status": "success", "data": response.json().get("results", [])}

Suggested tool description:

Search scientific papers with BGPT and return structured study evidence for critical appraisal, including methods, sample size/population, results, limitations, conflict-of-interest statements, data/code availability, study blind spots, quality scores, and how the claim could be falsified.

Suggested parameters: query, num_results, optional days_back, optional api_key.

Suggested test example: { "query": "GLP-1 alcohol craving", "num_results": 3 }.

This would be complementary to OpenAlex/PubMed-style discovery tools because BGPT is strongest when the agent needs evidence-quality fields before writing a scientific answer.

[gasvn]

Thanks for the suggestion, @connerlambden, and for the implementation sketch — the structured evidence fields (sample size, limitations, conflicts of interest, data/code availability, how_to_falsify) are a genuinely different shape from what the existing PubMed / EuropePMC / OpenAlex tools return, so I can see where it would fit in an evidence-appraisal workflow.

Before we'd take on the integration, a few things we need to understand for any external API we depend on:

• Auth & access: is https://bgpt.pro/api/mcp-search open, or does it require an API key? If a key is required, what are the rate limits and is there a free tier sufficient for evaluation/CI?
• Licensing / ToS: what are the terms for programmatic use and redistribution of the returned evidence fields?
• Stability & provenance: is the endpoint/response schema versioned? Where do the structured fields (quality scores, blind spots) come from — model-generated, or curated?
• Sustainability: what's the expected longevity of the service? We're cautious about adding hard dependencies on single-provider hosted endpoints.

If you can share those, we can evaluate adding it as an optional tool (gated behind an API key like our other external integrations). Given you're also the author of BGPT, we'd validate it against a couple of independent queries before merging.

[connerlambden]

For authentication, no API key is required for the 50 free answers, and then an API is required after that. For the Terms of Service, the data may be used or redistributed in any way. There is no schema versioning, and the structured fields are model-generated. The expected longevity of the service is forever. Thanks for the questions

[gasvn]

Hi, thank you for the contribution? Could you please clarify the criteria for the 50 free resets, as well as the registration process? Since agents utilize these tools automatically most of the time, clarifying these details will prevent the agents from incorrectly flagging the tools as unavailable.

[connerlambden]

Any unique IP is eligible for the 50 free results, then setting up a key will be required via Stripe (with a helpful message for agents)

[connerlambden]

Demo artifact now public.

EVIDENCE_DEMO.md walks through a claim-interrogation query and a Plotly dashboard built from live BGPT responses: https://github.com/connerlambden/bgpt-mcp/blob/main/EVIDENCE_DEMO.md

Pairs with the BaseTool wrapper sketch above — the demo makes the unusual fields (limitations, COI, how_to_falsify) visible without reading API docs.