Novelty Research MCP
Use this MCP server to conduct source-grounded prior-art research: it creates/manages research sessions, retrieves patent/publication/web evidence, applies deterministic relevance and evidence rules, tracks readiness for finalization, and generates a user report from SQLite-stored evidence.
Research sessions: start or update a session with an original query and get a session ID; later store query decomposition (English/original query, run ID) under the session.
Patent evidence: run patent evidence retrieval with configurable query, max fetches/results, timeout, attempt number, and persist a compact result to the session.
Publication evidence: retrieve publication evidence with similar parameters (source_type, fetch timeout) and store it in SQLite.
Web evidence: retrieve web evidence with configurable timeout/fetches/result limits and store it in the session.
Readiness check: check whether the session has enough evidence to finalize, using min_total_hits and max_attempts_per_source.
Report generation: produce the final user answer/report from the session's stored evidence, with optional debug_mode and force_regenerate.
Enables web searches through Google Custom Search Engine, serving as the primary backend for gathering web evidence during novelty research.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Novelty Research MCPCheck if a smart irrigation system that uses weather data is patented."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Novelty Research MCP
A Python MCP backend for source-grounded prior-art research across patents, scientific publications and the web. It records retrieval attempts and evidence in SQLite, applies deterministic relevance and evidence rules, and renders a report that distinguishes verified text, snippets and failed retrieval.
Built for my bachelor's thesis, AI for Advanced Information Research, then
hardened through a technical audit, regression tests and reproducible evaluation
work. The v1.0-thesis tag preserves the submitted prototype; 0.10.0 is the
post-thesis portfolio milestone, not a production-readiness claim.
Example report · Technical audit · Release verification · Slovensky
What I built and improved
Research backend: seven MCP tools, asynchronous provider retrieval, bounded retries, SQLite session state and source-grounded report generation.
Deterministic hardening: stable scoring/ranking tie-breaks, regression tests and defect-restoration negative controls. Identical inputs/configuration are the boundary; live provider responses are not deterministic.
Passive decision capture: candidate decisions and query/decomposition provenance stored separately from production evidence. Capture failures do not change retrieval or retry decisions. Provider errors omit credential-bearing exception text.
Reliability hardening: a documented defect→regression-test→controlled-fix→ remeasurement loop covering retry saturation, patent verification depth and identity, partial-retrieval diagnostics, provider observability and completeness propagation. Each fix landed with a control proving the test fails against the old behaviour.
Offline evaluation infrastructure: read-only snapshot import, explicit identity reconciliation, blank blinded worksheets and deterministic original-query roster rehearsal. These Goal 5C tools currently accept synthetic inputs only.
Related MCP server: pramana-mcp
Architecture
flowchart LR
U[Information need] --> F[Flowise supervisor]
F --> M[Seven Python MCP tools]
M --> P[Patent / publication / web providers]
P --> E[Deterministic relevance and evidence processing]
E --> D[(SQLite sessions and evidence)]
D --> C[Retry checklist]
C --> F
D --> R[Rendered report]
E -. passive capture .-> V[(Candidate-decision traces)]
V -. synthetic offline preparation .-> O[Reviewed identities and blank worksheets]The Flowise LLM orchestrates calls and supplies an English translation for non-English inputs. Retrieval, local scoring, evidence grading and rendering are Python code. The workflow instructs the supervisor to use compact acknowledgements and return the report verbatim, rather than rewriting raw evidence.
The tools are research_session_start, research_session_understand_query,
patent_evidence_to_session, publication_evidence_to_session,
web_evidence_to_session, research_session_checklist and
research_session_user_answer. Interface tests pin their names and parameters.
What is measured—and what is not
Evidence | Current scope |
Automated verification | 1311 tests on Python 3.11–3.13 CI. Determinism is checked by re-running two digested workloads in a fresh interpreter per |
Historical relevance benchmark | 3 queries / 20 candidates; fixed-pool generic-scorer regression benchmark. Query-macro precision 0.611, recall 0.833, F1 0.683. |
Goal 5C implementation | Synthetic/offline Phases 1–3 completed; import, reconciliation/blinding and roster-freeze contracts are tested. |
Real evaluation study | Not performed. No new participant acquisition, human labels, workflow metrics or prospective threshold confirmation. |
The benchmark uses shared generic scorer defaults, not a replay of all production search gates, fallbacks and retries. Its tiny, partly author-constructed dataset cannot establish general effectiveness, a meaningful improvement percentage or global retrieval recall. Tests are software checks, not independent study queries. See AUDIT §14.4.
This is research assistance, not a proof of novelty or patentability. Provider
blocking, rate limits, lexical matching and incomplete documents limit results.
claim_verified means claim text was obtained, not that legal anticipation was
established. Failed retrieval is not evidence that prior art is absent.
Verify offline first
No API credentials, Docker, browser installation or LLM account are needed for these checks. Python 3.11–3.13 is the CI-tested range; dependency installation requires internet access. From a terminal:
git clone https://github.com/RobackaB/novelty-research-mcp.git
cd novelty-research-mcp
python -m venv .venvActivate with source .venv/bin/activate on Linux/macOS, or
.venv\Scripts\Activate.ps1 in PowerShell. Then, from the repository root:
python -m pip install -e ".[dev]"
python -m pytest -q
python -m eval.relevance_eval
python -m eval.goal5c --helpeval and eval.goal5c are checkout tooling; they are not included in the server
wheel or runtime Docker image. The Goal 5C commands require synthetic contract
inputs: snapshot import,
reviewed preparation, and
roster freeze. Their tests provide executable
fixtures; generated artifacts belong outside Git. --sweep on the historical
evaluator explores trade-offs but does not authorize threshold changes.
Optional local Flowise demo
Use Docker Desktop and the Compose-pinned Flowise 3.1.4. Container startup and interactive import remain unverified on the release-check host; see the release smoke record. An OpenAI credential is needed only for the live Flowise model; provider keys in .env.example are optional and can enable additional retrieval paths. No key-free retrieval completeness is promised.
cp .env.example .env
# PowerShell: Copy-Item .env.example .env
docker compose up --buildOpen Flowise at
http://localhost:3000and complete its local account setup if prompted.Create/open an Agentflow V2, then use its settings import action (Load Agents) for
flowise_architecture/Flowise_agent.json.Set your own model credential and confirm access to the configured model.
Set the Custom MCP node URL to
http://mcp-research-server:8000/mcpwhen both services run in Compose. The historical export useshost.docker.internal; the service-name URL avoids routing through the host's published port.Describe an information need, for example: “A wireless sensor that monitors battery temperature and sends overheating alerts.”
This is a trusted local demo, not an authenticated public MCP service. Host/origin checks are not user authentication. Keep ports local, use non-sensitive inputs and do not expose it directly to the internet. Queries, evidence and some source URLs are persisted or logged.
Check docker compose ps and docker compose logs if startup or tools fail.
http://localhost:8000/mcp is an MCP protocol endpoint, not a browser homepage.
docker compose down stops the services and preserves their volumes;
docker compose down -v also deletes Flowise state and research data.
Project map and stopping point
Path | Purpose |
| stdio / Streamable HTTP MCP entry points |
| Retrieval, scoring, evidence, SQLite and passive capture |
| Offline regression, contract and negative-control tests |
| Historical benchmark and synthetic Goal 5C tooling |
| Current supervisor workflow export |
| Historical comparison workflows |
| Protocols, example, findings and release history |
Major feature development pauses at this portfolio milestone. Goal 5C Phase 4 has not started. The real pilot, 25–30 genuine queries, human labelling/adjudication, workflow-observed metrics and prospective threshold confirmation remain future research, subject to its operational/privacy gates. The completed synthetic phases do not complete that empirical study.
Available Tools
7 toolspatent_evidence_to_sessionC
Získa patentové dôkazy a uloží kompaktný výsledok do SQLite session.
| Name | Required | Description | Default |
|---|---|---|---|
| query | No | ||
| run_id | No | ||
| attempt_no | No | ||
| session_id | No | ||
| max_fetches | No | ||
| max_results | No | ||
| source_type | No | patent | |
| english_query | No | ||
| fetch_timeout_ms | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the burden of behavioral disclosure, and it does state the main side effect: writing a compacted result to SQLite. However, it does not disclose whether existing session data is overwritten or appended, whether network fetching can fail or time out, or what session state is required before calling the tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The single sentence is concise and front-loaded with the core action and destination. It contains no filler, though its brevity comes at the cost of omitting important operational and selection guidance.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a nine-parameter tool with no annotations and no parameter descriptions, this is clearly under-specified. An agent cannot determine required session fields, how attempt_no or max_fetches affect behavior, or when this tool should be chosen over the sibling evidence tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% and the description names none of the nine parameters. Field names like session_id, run_id, attempt_no, and max_fetches are suggestive, but the description provides no mapping between these parameters and patent retrieval or session storage behavior, leaving substantial ambiguity.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Získa' - gets) and identifies the resource (patent evidence), while also stating the outcome: storing a compact result into a SQLite session. It is clear enough to distinguish this from unrelated tools, though it does not explicitly differentiate it from the sibling evidence_to_session tools beyond the patent scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus publication_evidence_to_session or web_evidence_to_session, nor when it fits into the research session workflow. The intended usage must be inferred entirely from the tool name and sibling context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
publication_evidence_to_sessionC
Získa publikačné dôkazy a uloží kompaktný výsledok do SQLite session.
| Name | Required | Description | Default |
|---|---|---|---|
| query | No | ||
| run_id | No | ||
| attempt_no | No | ||
| session_id | No | ||
| max_fetches | No | ||
| max_results | No | ||
| source_type | No | publication | |
| english_query | No | ||
| fetch_timeout_s | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses a key side effect: it saves data to a SQLite session, which implies modifying session state. However, it does not mention whether it fetches external data, whether it overwrites existing session data, or any other potential side effects (e.g., network calls, rate limits). With no annotations, the description partially carries the transparency burden but falls short of full disclosure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence with no wasted words. It is well-structured and directly states the action and target. It could be slightly more informative, but it is appropriately brief and does not ramble.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (9 parameters, similar sibling tools, an output schema), the description is extremely sparse. It does not explain the purpose of each parameter, how this tool relates to sibling tools, what constitutes a 'compact result', or when to use it. The description is far from complete for an agent to select and invoke it correctly without additional context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema includes 9 parameters (query, run_id, attempt_no, session_id, max_fetches, max_results, source_type, english_query, fetch_timeout_s) but provides no descriptions for any of them, and the tool description does not explain their meaning or usage. The description coverage is 0%, leaving the agent with no semantic guidance from the description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's action: getting publication evidence and saving a compact result to a SQLite session. The verb 'gets' and 'saves' are specific, and the resource ('publication evidence') distinguishes it from sibling tools (patent, web). However, 'compact result' is not defined, so it's not perfectly precise.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no explicit guidance on when to use this tool versus its siblings (patent_evidence_to_session, web_evidence_to_session). The word 'publication' implies it is for publication sources, but this is only implicit and not clearly contrasted with alternatives. No context or decision criteria are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
research_session_checklistC
Skontroluje, či má research session dosť dôkazov na finalizáciu.
| Name | Required | Description | Default |
|---|---|---|---|
| run_id | No | ||
| session_id | Yes | ||
| min_total_hits | No | ||
| max_attempts_per_source | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It says the tool 'checks' a condition, which implies a read-only operation, but it does not disclose what the outcome looks like, whether thresholds like min_total_hits affect the result, or whether any state changes occur.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single direct sentence with no filler or repetition. It front-loads the action and condition, making it very easy to parse, though it is also short enough that the lack of operational detail is noticeable.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no annotations, 0% parameter description coverage, and four parameters, this one-line description is under-specified for safe invocation. An output schema exists, so omitting return-value details is acceptable, but the description still leaves the agent guessing about usage conditions, parameter meaning, and side effects.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description adds no parameter-level detail. The word 'dosť dôkazov' loosely relates to min_total_hits, but run_id, session_id, min_total_hits, and max_attempts_per_source are not explained in the description. Property names and defaults in the schema do some work, but the description does not compensate for the missing schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action ('Skontroluje'), a specific resource ('research session'), and the condition being checked ('dosť dôkazov na finalizáciu'). This is clear enough for an agent to know the tool is a verification gate rather than an evidence-adding action, even though it does not explicitly name a sibling alternative.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is used to decide whether a research session can be finalized, but it does not explicitly state when to call it versus alternatives such as research_session_understand_query or the evidence_to_session tools. There is no when-not-to-use guidance or named alternative, so the agent must infer the usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
research_session_startC
Vytvorí alebo aktualizuje SQLite research session a vráti jej identifikátor.
| Name | Required | Description | Default |
|---|---|---|---|
| session_id | No | ||
| original_query | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral disclosure burden. It does disclose that the tool both creates and updates a session and returns an identifier, which is useful. However, it does not explain how the create-vs-update decision is made (e.g., based on session_id), what happens to existing data, or any side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single efficient sentence that front-loads the core action and return value. It contains no waste, though it is too brief to carry the full explanatory burden for a tool with no annotations and no output schema.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no annotations, no output schema, and several sibling tools operating on the same session concept, the description is incomplete. It does not clarify how session_id controls create vs update, how this tool relates to evidence_to_session or user_answer tools, or what the returned identifier should be used for.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description does not mention original_query or session_id at all. The schema names and default provide some minimal meaning, but the description adds no parameter-level semantics beyond what is already in the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action ('creates or updates'), a clear resource ('SQLite research session'), and a return value (identifier). This makes the tool's purpose understandable and distinguishes it from siblings like research_session_understand_query or evidence_to_session tools, though it does not name a sibling explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives no guidance on when to use this tool versus the sibling tools, and no conditions such as 'use when starting a new session' or 'use when updating an existing session'. The usage context must be inferred entirely from the tool name and sibling list.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
research_session_understand_queryC
Rozloží a uloží očistené údaje dotazu pre výskumnú reláciu.
| Name | Required | Description | Default |
|---|---|---|---|
| run_id | No | ||
| session_id | Yes | ||
| english_query | No | ||
| original_query | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavior itself. It does reveal a side effect ('uloží' / saves), but it does not specify whether data is overwritten, whether a session must already exist, whether the operation is idempotent, or what happens to incomplete input. The phrase 'očistené údaje dotazu' is vague about what transformation actually occurs.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single sentence with no filler, front-loading the main action 'Rozloží a uloží' before the object. It is concise and easy to scan, though the brevity contributes to under-specification.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a stage-like tool among several research_session siblings, with no annotations and 0% parameter description coverage, a one-line purpose is not enough. The agent lacks when-to-use, parameter meaning, and behavioral consequences. The presence of an output schema helps return-value understanding, but the description still fails to complete the invocation context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% while there are 4 parameters, so the description needs to compensate. It only refers generally to 'dotazu' (query) and 'výskumnú reláciu' (research session), which hints at query-related parameters and session_id but says nothing about run_id, english_query, original_query, or their roles.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The Slovak description 'Rozloží a uloží očistené údaje dotazu pre výskumnú reláciu' clearly states a verb and resource: it decomposes and saves cleaned query data for a research session. This is more than a tautology and is distinguishable by name from siblings, but it does not explain what 'understand' concretely produces or how this stage differs from sibling queries.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given about when this tool should be used instead of siblings such as research_session_start or research_session_user_answer. There are no prerequisites, no exclusions, and no indication of how this fits into the research-session pipeline.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
research_session_user_answerC
Vráti finálny používateľský report z dôkazov uložených v SQLite.
| Name | Required | Description | Default |
|---|---|---|---|
| run_id | No | ||
| debug_mode | No | ||
| session_id | Yes | ||
| original_query | No | ||
| force_regenerate | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It does not mention whether the operation is read-only, has side effects, or how the force_regenerate parameter influences behavior. This lack of transparency could lead to incorrect assumptions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence with no unnecessary words. However, its brevity sacrifices detail, making it efficient but not optimally informative.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of 5 parameters and no annotations, the description is far from complete. It fails to explain the purpose of each parameter, when to invoke the tool, or what the output schema contains, leaving significant gaps in the agent's understanding.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 5 parameters with zero coverage, and the description does not mention any of them. There is no explanation of what run_id, session_id, debug_mode, original_query, or force_regenerate mean, leaving the agent without sufficient information to populate them correctly.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns a final user report from evidence stored in SQLite, using the specific verb 'returns' and identifying the resource. It is distinct from sibling tools that start sessions, understand queries, add evidence, or manage checklists.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given on when to use this tool versus alternatives. The description only states what it does, without mentioning any prerequisites, conditions, or scenarios where it is the appropriate choice.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
web_evidence_to_sessionC
Získa webové dôkazy a uloží kompaktný výsledok do SQLite session.
| Name | Required | Description | Default |
|---|---|---|---|
| query | No | ||
| run_id | No | ||
| attempt_no | No | ||
| session_id | No | ||
| timeout_ms | No | ||
| max_fetches | No | ||
| max_results | No | ||
| source_type | No | web | |
| english_query | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of transparency. It does disclose that the tool stores data in a SQLite session, which is a side effect. However, it omits details about the storage mechanism, potential overwrites, or any other effects that could impact the session state.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence with no redundant wording. It efficiently conveys the core purpose without unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of the tool (9 parameters and an output schema), the one-sentence description is too brief. It does not explain what constitutes 'web evidence', how the parameters affect behavior, what the 'compact result' contains, or the expected return format. The description is inadequate for an agent to fully understand how to invoke or interpret the tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 0%. None of the 9 parameters (query, run_id, attempt_no, etc.) are explained in the description, leaving the agent to infer meanings solely from parameter names, which may be ambiguous.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: it obtains web evidence and stores a compact result in SQLite session. This explicitly distinguishes it from sibling tools like patent_evidence_to_session and publication_evidence_to_session, which focus on other evidence types.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus the alternatives. It does not mention prerequisites, appropriate contexts, or situations where other evidence tools would be preferred.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
7 tool updates
v0.9.5- First observed
patent_evidence_to_session - First observed
publication_evidence_to_session - First observed
research_session_checklist - First observed
research_session_start - First observed
research_session_understand_query - First observed
research_session_user_answer - First observed
web_evidence_to_session
TDQS
Scored across 7 tools
Each tool targets a distinct phase of the research pipeline: session creation, query decomposition, three evidence sources (patent/publication/web), readiness checking, and final report generation. The three evidence tools differ only by source type, which is an intentional and clear parallel structure rather than a source of confusion.
Tool names follow two clear patterns: research_session_* for lifecycle operations and {source}_evidence_to_session for evidence gathering, all in snake_case. Minor deviation: research_session_checklist and research_session_user_answer use nouns rather than verbs, breaking the otherwise consistent verb-first convention.
Seven tools map cleanly onto the novelty research workflow with no redundancy. Each tool earns its place in the pipeline, and the count is well within the ideal 3-15 range for a focused server.
The full research workflow is covered: start session, decompose query, gather evidence from three sources, check readiness, and produce the final report. Minor gaps exist—no way to delete/reset a session or remove incorrectly stored evidence—but these are edge cases rather than workflow-breaking omissions.
Maintenance
Related MCP Connectors
AI-powered patent intelligence for search & analysis
Global patent search, briefs, similarity, citations and landscape stats. Strong China coverage.
Find products & standards using a patent - verified targets for licensing or enforcement.
Semantic patent search & analysis: find, compare, and analyze patents by meaning.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceAI-powered patent search and analysis across 220M+ global patents. Semantic search, prior art discovery, novelty/patentability reports, and patent content retrieval.Apache 2.0
- AlicenseNot gradedqualityDmaintenanceEnables citation-audited deep research with tools for web-grounded answers, source conflict detection, and per-claim citation auditing.MIT
- FlicenseNot gradedqualityFmaintenanceAutomates literature review, research gap detection, and novelty evaluation for academic research, providing tools to search, summarize, find gaps, generate ideas, and evaluate novelty.-
- AlicenseAqualityDmaintenanceAutomates high-credibility research with multi-source search and 10+ rounds of cross-verification.612 npmMIT