superlenz
Provides access to academic papers from arXiv for research and citation.
Enables web search via Brave Search API for gathering up-to-date information.
Supports saving research documents to Confluence as a storage provider.
Allows searching GitHub repositories as a source for research.
Supports saving research documents in Markdown format for easy readability.
Supports saving research documents to Notion as a storage provider.
Enables searching Reddit for community discussions as a research source.
Integrates with Semantic Scholar to search academic papers with improved rate limits.
Enables searching YouTube videos as a research source.
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., "@superlenzresearch the latest breakthroughs in fusion energy"
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.
SuperLenz
Lenz — from Latin "lenticula" (lens). A super-powered lens that magnifies the truth. SuperLenz searches multiple sources, cross-verifies every claim through 10+ rounds, and delivers only credible, validated research.
High-credibility research automation with multi-source cross-verification (10+ rounds)
A Model Context Protocol (MCP) server that automates research tasks with a focus on credibility and accuracy. It performs automatic searching, collection, cross-verification (10+ rounds), and saves results to your preferred storage.
Features
Multi-Source Search: Web search (Brave, Exa), academic papers (arXiv, Semantic Scholar), GitHub
10-Round Cross-Verification: Keyword overlap matching (rounds 1-4), conflict detection (5-8), optional LLM verification (9-10)
Credibility Scoring: Authority assessment, temporal validation, source weighting
Flexible Storage: Markdown (default), JSON
Plugin Architecture: Extensible storage and search providers
Related MCP server: DeepResearch MCP
Requirements
Node.js >= 18.0.0
Any MCP-compatible client
Environment Variables
SuperLenz reads these from the system environment. If a key is available, the corresponding feature is automatically enabled. No key is strictly required — arXiv search is always available.
Variable | Required | Description |
| No | Brave Search API key |
| No | Exa Search API key |
| No | Semantic Scholar API key (improves rate limits) |
| No | GitHub token for repository search |
| No | Enables LLM-based verification (rounds 9-10) |
| No | Output directory for saved documents (default: |
Tip: If your MCP client supports an
"env"field, you can pass keys there instead of setting them system-wide.
MCP Client Configuration
All examples below use npx — no prior installation required.
Claude Desktop
No CLI — edit the JSON config file directly.
Edit ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):
{
"mcpServers": {
"superlenz": {
"command": "npx",
"args": ["-y", "superlenz"]
}
}
}Claude Code (CLI)
Option A — CLI command:
claude mcp add superlenz -- npx -y superlenzFlag | Description |
| Save to |
| Save to |
| Save to |
| Set an environment variable |
| Transport type: |
Management commands:
claude mcp list # list registered servers
claude mcp remove superlenz # remove a serverOption B — JSON config:
Edit ~/.claude/settings.json (or .claude/settings.json at the project root):
{
"mcpServers": {
"superlenz": {
"command": "npx",
"args": ["-y", "superlenz"]
}
}
}Cursor
No CLI "add" command — edit the config file or use the Settings UI.
Open Settings > MCP Servers and add, or edit .cursor/mcp.json (project) / ~/.cursor/mcp.json (global):
{
"mcpServers": {
"superlenz": {
"command": "npx",
"args": ["-y", "superlenz"]
}
}
}Management commands (in Cursor's terminal):
cursor agent mcp list # list servers
cursor agent mcp enable <id> # enable a server
cursor agent mcp disable <id> # disable a serverVS Code (Copilot)
Option A — CLI command:
code --add-mcp '{
"name": "superlenz",
"command": "npx",
"args": ["-y", "superlenz"]
}'Option B — JSON config:
Edit .vscode/mcp.json in your workspace. Note: VS Code uses the "servers" key (not "mcpServers").
{
"servers": {
"superlenz": {
"command": "npx",
"args": ["-y", "superlenz"]
}
}
}Or add to VS Code settings.json under "mcp.servers".
Gemini CLI
Option A — CLI command:
gemini mcp add superlenz npx -y superlenzManagement commands:
gemini mcp list # list registered servers
gemini mcp remove superlenz # remove a serverOption B — JSON config:
Edit ~/.gemini/settings.json:
{
"mcpServers": {
"superlenz": {
"command": "npx",
"args": ["-y", "superlenz"]
}
}
}MCP Tools
start_research
Start a new research session. Searches multiple sources, cross-verifies claims, generates a document, and saves the result.
Parameter | Type | Default | Description |
| string | (required) | Research topic or question |
| string[] | — | Initial URLs to include in research |
|
|
| Verification depth (5 / 10 / 15 rounds) |
|
|
| Storage provider for the final document |
|
|
| Document template |
search_sources
Search for sources across multiple providers without running a full research pipeline.
Parameter | Type | Default | Description |
| string | (required) | Search query |
| string[] |
| Providers: |
| number |
| Maximum results per source (1-50) |
| number |
| Minimum relevance score (0-1) |
get_research_status
Get the current status of a research session.
Parameter | Type | Default | Description |
| string | (required) | Session ID to check |
list_sessions
List all research sessions with optional filtering.
Parameter | Type | Default | Description |
| string | — | Filter by status: |
| number |
| Max sessions to return (1-100) |
cross_verify
Cross-verify a list of claims against optional source URLs.
Parameter | Type | Default | Description |
| string[] | (required) | List of claims to verify |
| string | (required) | Topic context for verification |
| string[] | — | Optional source URLs to check against |
save_to_storage
Save a previously generated research document to a storage provider.
Parameter | Type | Default | Description |
| string | (required) | Session ID of the research to save |
|
|
| Storage provider |
| string | — | Custom file path or name |
License
MIT
Available Tools
6 toolscross_verifyA
Cross-verify a list of claims against optional source URLs. Returns verification confidence and conflict analysis.
| Name | Required | Description | Default |
|---|---|---|---|
| topic | Yes | Topic context for verification | |
| claims | Yes | List of factual claims to verify | |
| sources | No | Optional source URLs to check claims against |
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 disclosing behavioral traits. It only states that the tool returns verification confidence and conflict analysis, which implies a read-only operation, but it does not explicitly say whether it modifies any state, requires specific permissions, or has limitations (e.g., handling missing/invalid sources). The lack of explicit safety or side-effect information leaves the agent without a clear picture of consequences beyond the output.
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 two short sentences that directly state the tool's function and output. It is efficient, front-loaded, and contains no redundant or filler content. Every word contributes to conveying the core purpose.
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 output schema and simple inputs, the description gives a high-level overview but lacks detail on the format or semantics of the returned 'verification confidence' and 'conflict analysis'. It also does not explain behavior when no sources are provided or how claims are processed. Given the absence of an output schema and annotations, the description is adequate but not fully complete for an agent to anticipate results or edge cases.
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 already provides 100% coverage with descriptions for all three parameters (topic, claims, sources). The tool description adds minimal additional meaning beyond what the schema states—it merely mentions 'claims' and 'optional source URLs' which are already in the schema. Thus, the description does not significantly enhance parameter understanding beyond the baseline.
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 identifies the tool's purpose: cross-verifying a list of claims against optional source URLs. It uses a specific verb ('cross-verify') and states the resource (claims/sources) and the deliverables (verification confidence and conflict analysis). This distinguishes it from sibling tools like search_sources or start_research, which focus on gathering or managing research.
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 for verifying claims and optionally using source URLs, but it does not explicitly state when to use this tool versus alternatives or mention any exclusions. There is no guidance on prerequisites (e.g., needing sources first) or when not to use it, so the usage context is only implied rather than directly instructed.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_research_statusB
Get the current status of a research session
| Name | Required | Description | Default |
|---|---|---|---|
| sessionId | Yes | Session ID to check |
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 behavioral disclosure. It only states a read-like action ('Get') but does not disclose details such as possible status values, whether the session must exist, error behavior, or any side effects. The minimal wording leaves significant behavioral ambiguity.
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, focused sentence that immediately states the purpose. It is succinct and front-loaded, with no unnecessary words or filler, making it easy for an agent to parse quickly.
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 simple tool with one parameter and no output schema, the description adequately conveys the core function. However, it could be slightly more complete by hinting at what 'status' entails (e.g., running, completed, failed) or how to handle missing sessions, but the current form is sufficient for basic selection and invocation.
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 already provides 100% coverage for the single parameter (sessionId) with a clear description ('Session ID to check'). The tool description adds no additional parameter semantics beyond reiterating that it pertains to a research session, so the baseline of 3 is appropriate.
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 'Get the current status of a research session' uses a specific verb ('Get') and a clear resource ('current status of a research session'), which distinctly identifies the tool's function. It is clearly differentiated from sibling tools like start_research or list_sessions, which have different actions or scopes.
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 alternatives or any prerequisites or context. It simply states the action without explaining scenarios where this tool is preferred over siblings like list_sessions or get_research_status.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_sessionsB
List all research sessions with optional filtering
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum number of sessions to return | |
| status | No | Filter by status |
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 disclosing behavior. It only states 'list all' with optional filtering, but does not mention whether it is read-only, whether it returns all sessions across users, or any rate limits or side effects. The default limit of 20 is not disclosed in the description, leaving important behavioral traits unaddressed.
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: 'List all research sessions with optional filtering.' It is front-loaded with the action, contains no filler, and is appropriately sized for the tool's complexity.
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?
The tool is simple with two optional parameters fully documented in the schema, and the description conveys the core purpose. However, there is no output schema and no mention of return format, pagination behavior, or what fields are included. The absence of annotations and the lack of detail in the description leave some gaps, but the schema compensates for parameter information.
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 has 100% description coverage for both parameters (limit and status), so the baseline is 3. The description's 'optional filtering' adds no specific detail beyond what the schema provides. It does not name the filters or explain their usage, so it adds minimal value over 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 clearly states the tool lists research sessions and mentions optional filtering. This distinguishes it from siblings like start_research and get_research_status, which create or retrieve individual sessions. The verb 'list' and resource 'research sessions' are specific and unambiguous.
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. There is no mention of get_research_status for single-session status, no exclusions, and no context indicating whether it should be used for active sessions only. The intended use is only implied by the name.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
save_to_storageA
Save a previously generated research document to a specific storage provider (markdown or json)
| Name | Required | Description | Default |
|---|---|---|---|
| provider | No | Storage provider to use | markdown |
| sessionId | Yes | Session ID of the research document to save | |
| destination | No | Optional custom file path or name |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It does not mention side effects like file overwriting, permissions, or what happens if the session is invalid, nor does it explain the meaning of 'storage provider' beyond formats. This is a significant gap for a save operation.
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, clear sentence that states the action, object, and target without any filler or redundancy. It earns its place and is easy to scan.
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?
The tool is simple and the schema fully describes all parameters, but the lack of annotations and output schema means the description should provide more context about the save behavior, such as default destination or error handling. It is minimally adequate but leaves open questions about 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 100% for all three parameters, so the baseline is 3. The description adds limited extra meaning—it restates the markdown/json enum values, but does not explain the destination parameter or provide syntax. The schema already carries the semantic weight.
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 ('Save'), identifies the exact resource ('previously generated research document'), and names the target ('storage provider') with explicit formats (markdown or json). This clearly distinguishes it from the sibling research and status tools.
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 phrase 'previously generated research document' implies the tool should be used after research is complete, but there is no explicit guidance on when to prefer this tool over alternatives or any stated exclusions. The context is present but not stated as a rule.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_sourcesB
Search for sources across multiple providers (web, academic, GitHub, etc.)
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum results per source | |
| query | Yes | Search query | |
| sources | No | Search providers to use | |
| minRelevance | No | Minimum relevance score (0-1) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It mentions multi-provider search but does not explain result merging, pagination, output format, rate limits, or any side effects. The behavioral coverage is minimal and leaves the agent guessing about important runtime characteristics.
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, front-loaded sentence that wastes no words. It conveys the core purpose and scope efficiently, earning a top score for conciseness.
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 has four parameters, no annotations, and no output schema, the description is too sparse. It does not explain return behavior, result ordering, default provider behavior, or how 'minRelevance' and 'limit' influence results. The agent would need to infer too much, making the description incomplete for effective invocation.
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 100%, so the schema already documents all four parameters. The description adds almost no extra parameter meaning beyond the phrase 'multiple providers', which is already reflected in the 'sources' parameter. Therefore, the baseline of 3 is appropriate since the schema does the heavy lifting.
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 a specific verb ('Search') and resource ('sources'), and further scopes it to 'multiple providers (web, academic, GitHub, etc.)'. This distinguishes it from sibling tools like start_research or cross_verify, which have different purposes.
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 when to use the tool (whenever a cross-provider source search is needed) but provides no explicit exclusions or alternatives. It does not mention when not to use it or compare it to siblings like cross_verify, so the guidance is only implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
start_researchA
Start a new research session with automatic multi-source search, collection, and cross-verification
| Name | Required | Description | Default |
|---|---|---|---|
| urls | No | Optional initial URLs to analyze (user-provided sources) | |
| depth | No | Verification depth: quick (5 rounds), standard (10 rounds), deep (15+ rounds) | standard |
| topic | Yes | The research topic or question | |
| storage | No | Storage provider for the final document | markdown |
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 behavioral disclosure. It states that the tool performs automatic multi-source search, collection, and cross-verification, which are meaningful behaviors. However, it does not disclose the session lifecycle, whether it is asynchronous, how to track progress via get_research_status, or what happens with user-provided URLs or storage settings.
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, front-loaded sentence that precisely states the tool's purpose without any fluff or repetition. Every word contributes meaning, and the description is appropriately concise for the tool's complexity.
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?
The description provides a high-level overview but lacks information about the output of the session, how to retrieve results, and the asynchronous nature of research. Since there is no output schema, the description should explain what the caller can expect in return, but it does not. However, the complete parameter schemas partially compensate for this gap.
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 already provides descriptions for all four parameters, including enums and defaults, so the schema description coverage is 100%. The tool description adds no additional parameter-specific detail, which corresponds to the baseline score of 3 for high schema coverage.
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-action ('Start a new research session') and clearly differentiates this tool from its siblings by describing the automatic multi-source search, collection, and cross-verification process. It identifies exactly what resource is being acted upon (a research session) and the high-level workflow, making the purpose unmistakable.
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 begin a research session, but it provides no explicit guidance on when to choose this tool over alternatives like search_sources or cross_verify. There are no prerequisites, exclusions, or alternatives mentioned, leaving usage context to be inferred.
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.
6 tool updates
v0.2.4- First observed
cross_verify - First observed
get_research_status - First observed
list_sessions - First observed
save_to_storage - First observed
search_sources - First observed
start_research
TDQS
Scored across 6 tools
Each tool has a distinct role: starting a session, searching sources, checking status, listing sessions, cross-verifying claims, and saving output. Potential overlap between start_research and search_sources is resolved by start_research being a higher-level session creation, while search_sources is a standalone utility.
All tool names follow a clear verb_noun pattern in snake_case (start_research, search_sources, get_research_status, list_sessions, save_to_storage). Even cross_verify is a verb phrase, maintaining a consistent action-oriented style.
With 6 tools, the set is well-scoped for a research workflow without being too small or bloated. Each tool addresses a specific step in the process, making the count feel appropriate and complete.
The domain covers starting research, searching, checking status, listing sessions, cross-verifying, and saving. However, there is no direct way to retrieve the generated research document content; the agent must rely on save_to_storage to access results, which is a notable gap in the output lifecycle.
Maintenance
Related MCP Connectors
Cross-source search across 18 real-time data sources, source-cited and corroboration-checked.
Source-traced evidence research for AI agents. We organise the evidence; you decide.
Real-time web and scholarly search with cited answers and multi-step deep research.
Real-time fact-check, citation verification, and source-freshness for AI agents.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables iterative deep research by integrating AI agents with search engines, web scraping, and large language models for efficient data gathering and comprehensive reporting.8 npm322MIT
- AlicenseDqualityDmaintenanceA powerful research assistant that conducts intelligent, iterative research through web searches, analysis, and comprehensive report generation on any topic.43 npm27Apache 2.0
- AlicenseNot gradedqualityDmaintenanceEnhances LLM applications with deep autonomous web research capabilities, delivering higher quality information than standard search tools by exploring and validating numerous trusted sources.368MIT
- AlicenseAqualityCmaintenanceEnables AI agents to perform professional-grade deep research by aggregating real-time data from multiple sources, evaluating source credibility, and generating comprehensive reports.311Apache 2.0