Skip to main content
Glama
alucardeht

ISIS MCP

by alucardeht
OverviewSchemaRelated ServersScoreDiscussions
TypeScript
Local

ISIS MCP

An open-source MCP (Model Context Protocol) server for local web scraping with RAG capabilities. Provides a free, API-key-free alternative to Apify RAG Web Browser.

Features

  • RAG Tool: Intelligent web search with content extraction (Multi-provider fallback (DuckDuckGo → SearXNG → ScraperAPI) + Mozilla Readability + Markdown conversion)

  • Scrape Tool: Extract content from specific URLs with optional CSS selectors

  • Screenshot Tool: Capture visual snapshots of web pages

  • SQLite Caching: Persistent cache to avoid redundant requests

  • Parallel Processing: Efficiently handle multiple page extractions

  • No API Keys Required: Self-contained, privacy-focused approach

Related MCP server: crawl4ai-mcp-server

Installation

Step 1: Install Globally

npm install -g isis-mcp

Step 2: Register with Claude Code

macOS/Linux

claude mcp add --transport stdio isis-mcp -- npx -y isis-mcp

Windows

claude mcp add --transport stdio isis-mcp -- cmd /c npx -y isis-mcp

This registers the MCP in user scope (available across all projects).

Important: Restart Claude Code after installation.

Step 3: Search Providers (Auto-configured)

ISIS-MCP uses an automatic fallback chain - no configuration needed:

Priority

Provider

Config Required

Notes

1

DuckDuckGo

None

Primary, always available

2

SearXNG Local

Docker installed

Auto-starts container on first use

3

ScraperAPI

SCRAPER_API_KEY env var

Optional paid fallback

4

Public SearXNG

None

Free but slower/unreliable

Option A: Docker SearXNG (Recommended)

Just have Docker installed - ISIS-MCP handles the rest:

# Verify Docker is installed
docker --version

# That's it! On first RAG request, ISIS-MCP will:
# 1. Create container "isis-searxng"
# 2. Mount custom config (docker/searxng/settings.yml)
# 3. Start on port 8080
# 4. Wait for ready state

Manual commands (macOS/Linux):

# Check status
docker ps | grep isis-searxng

# View logs
docker logs isis-searxng

# Restart
docker restart isis-searxng

# Remove (will auto-recreate on next use)
docker rm -f isis-searxng

Manual commands (Windows - PowerShell):

# Check status
docker ps | Select-String isis-searxng

# View logs
docker logs isis-searxng

# Restart
docker restart isis-searxng

# Remove (will auto-recreate on next use)
docker rm -f isis-searxng

Windows Docker Desktop Notes:

  • Ensure "Start Docker Desktop when you log in" is enabled in preferences for automatic startup

  • WSL 2 backend is recommended over Hyper-V for better performance

  • If Docker takes time to start, you may see timeout errors on first RAG request—just retry after Docker is ready

Option B: ScraperAPI (Optional - Paid Fallback)

  1. Create account at ScraperAPI

  2. Set environment variable:

macOS/Linux (Bash/Zsh):

export SCRAPER_API_KEY="your-key-here"

Make it permanent:

echo 'export SCRAPER_API_KEY="your-key-here"' >> ~/.zshrc
source ~/.zshrc

Windows (CMD):

set SCRAPER_API_KEY=your-key-here

Windows (PowerShell):

$env:SCRAPER_API_KEY="your-key-here"

For permanent Windows configuration, use System Properties → Environment Variables or run:

setx SCRAPER_API_KEY "your-key-here"

Alternative: Via Claude Code CLI (Legacy)

macOS/Linux

If you prefer npx-based installation:

claude mcp add isis-mcp -- npx -y github:alucardeht/isis-mcp

For user-level global installation:

claude mcp add -s user isis-mcp -- npx -y github:alucardeht/isis-mcp

Windows

claude mcp add isis-mcp -- cmd /c npx -y github:alucardeht/isis-mcp

For user-level global installation:

claude mcp add -s user isis-mcp -- cmd /c npx -y github:alucardeht/isis-mcp

Manual Configuration

macOS/Linux

Add the following to your claude_desktop_config.json:

{
  "mcpServers": {
    "isis-mcp": {
      "command": "npx",
      "args": ["-y", "github:alucardeht/isis-mcp"]
    }
  }
}

Windows

Add the following to your claude_desktop_config.json:

{
  "mcpServers": {
    "isis-mcp": {
      "command": "cmd",
      "args": ["/c", "npx", "-y", "github:alucardeht/isis-mcp"]
    }
  }
}

Troubleshooting Installation

"All search providers failed"

Cause: No provider configured or available.

Solution:

  1. Configure SearXNG Local (Option A) OR ScraperAPI (Option B)

  2. Verify service is running:

    • macOS/Linux: curl http://localhost:8080/search?q=test&format=json

    • Windows: Use Postman, curl (if installed), or PowerShell:

      Invoke-WebRequest -Uri "http://localhost:8080/search?q=test&format=json"

  3. If using ScraperAPI, confirm env var:

    • macOS/Linux: echo $SCRAPER_API_KEY

    • Windows CMD: echo %SCRAPER_API_KEY%

    • Windows PowerShell: $env:SCRAPER_API_KEY

Slow Performance

Global vs npx comparison:

Method

Startup

Cache

Re-download

Recommended

npx isis-mcp

~1-3s

NPX cache

Yes (3-7 days)

❌

npm install -g

~240ms

Persistent

Never

✅

If still slow:

  • Is SearXNG Local running?

  • Is ScraperAPI key configured?

  • Are public instances overloaded?

Claude Code Not Detecting MCP

  1. Verify installation: npm list -g isis-mcp

  2. Restart Claude Code completely

  3. Check MCP status: claude mcp list (if available)

  4. Re-run: claude mcp install isis-mcp -s user

Available Tools

rag (Primary Tool)

Web search with intelligent content extraction. Works like Apify RAG Web Browser:

  1. Search via multi-provider fallback (DuckDuckGo → SearXNG → ScraperAPI → Public instances)

  2. Extract content from discovered pages in parallel

  3. Convert to Markdown using Mozilla Readability

  4. Return structured result with caching

Parameters:

  • query (required): Search term

  • maxResults (optional): Maximum number of pages to retrieve (1-10, default: 5)

  • outputFormat (optional): markdown | text | html (default: markdown)

  • useJavascript (optional): Render JavaScript with Playwright (default: false)

Example:

Search for "nodejs best practices" and provide a summary

scrape

Extract content from a specific URL.

Parameters:

  • url (required): Page URL

  • selector (optional): CSS selector for specific element

  • javascript (optional): Render JavaScript before extraction

Example:

Extract the main content from https://nodejs.org/en/learn

screenshot

Capture a screenshot of a web page.

Parameters:

  • url (required): Page URL

  • fullPage (optional): Capture entire page (default: false)

  • width (optional): Viewport width in pixels (default: 1920)

  • height (optional): Viewport height in pixels (default: 1080)

Example:

Take a screenshot of https://example.com

Architecture

ISIS MCP v3.0
├── Search (Multi-provider fallback chain)
├── Docker Auto-Start (SearXNG local container)
├── Extraction (Mozilla Readability + Turndown)
├── Caching (SQLite at ~/.isis-mcp-cache.db)
└── Parallel Processing

The server uses a modular architecture where each component can be extended independently:

  • Search Module: Multi-provider fallback chain (DuckDuckGo → SearXNG → ScraperAPI → Public instances)

  • Docker Integration: Automatic SearXNG container management on port 8080

  • Extraction Module: Uses Mozilla Readability for intelligent content parsing and Turndown for HTML-to-Markdown conversion

  • Cache Layer: SQLite-based persistent cache to minimize redundant requests

  • Processing Pipeline: Parallel extraction of multiple pages for improved performance

Requirements

All Platforms

  • Node.js 18+ - Required

  • Playwright Chromium - Installed automatically

  • Docker (recommended) - For local SearXNG. Auto-starts on first use. Fallback providers work without Docker.

Platform-Specific

macOS

  • Docker Desktop for Mac (optional, for SearXNG Local)

Linux

  • Docker Engine (optional, for SearXNG Local)

Windows

  • Docker Desktop for Windows (optional, for SearXNG Local)

  • When using Docker: Enable WSL 2 backend for best compatibility

  • If you see Playwright browser errors, run: npx playwright install

Search Fallback Chain

ISIS-MCP automatically tries providers in order until one succeeds:

DuckDuckGo (Primary)
    ↓ if fails
SearXNG Local (Docker container on port 8080)
    ↓ if fails
ScraperAPI (if SCRAPER_API_KEY configured)
    ↓ if fails
Public SearXNG Instances (7 fallback servers)

Features:

  • Exponential backoff on rate limits

  • User-agent rotation for reliability

  • Automatic Docker container management

  • Graceful degradation to public instances

Token Optimization Features

The RAG tool has been enhanced with progressive token optimization to handle large content efficiently.

Phase 1: Content Modes

Control how much content is returned per result:

// Preview mode - Truncate to ~300 characters (70-80% reduction)
await rag({
  query: "react hooks",
  contentMode: "preview"
})

// Full mode - Complete content (default, backward compatible)
await rag({
  query: "react hooks",
  contentMode: "full"
})

// Summary mode - Intelligent LLM summarization (Phase 3)
await rag({
  query: "react hooks",
  contentMode: "summary"
})

Benefits:

  • preview: Fast, compact results (~6k tokens vs ~20k)

  • full: Complete content (original behavior)

  • summary: Intelligent 150-200 word summaries via LLM

Phase 2: Deferred Content Fetching

Fetch full content after preview using content handles:

// Step 1: Get preview with handle
const preview = await rag({
  query: "react hooks",
  contentMode: "preview",
  maxResults: 5
})

// Each result includes contentHandle (BASE64 of URL)
const handle = preview.results[0].contentHandle

// Step 2: Fetch full content when needed
const full = await fetchFullContent({
  contentHandle: handle,
  outputFormat: "markdown"
})
// Returns: Complete content from cache (1-hour TTL)

Benefits:

  • Lazy loading: Only fetch what you need

  • Cache reuse: No re-scraping required

  • Deterministic handles: Same URL = same handle

Phase 3: Progressive Summarization

Intelligent content summarization using local Ollama LLM.

Setup (Optional - Zero Config)

  1. Install Ollama (if not already):

macOS/Linux:

curl -fsSL https://ollama.ai/install.sh | sh
# Or download from https://ollama.ai

Windows:

  1. Pull a model (recommended):

ollama pull llama3.2:1b  # Fast, good quality (1.3GB)
# or
ollama pull mistral:7b   # Premium quality, slower (4GB)

  1. Start Ollama (if not running):

macOS/Linux:

ollama serve

Windows:

  • Ollama runs as a background service after installation

  • To verify it's running, open http://localhost:11434/api/tags in your browser

  • If needed, restart from Windows Services (search "Services" in Start menu)

Usage

Basic summarization (auto-detection):

const result = await rag({
  query: "react hooks best practices",
  contentMode: "summary"
})
// Auto-detects Ollama, uses llama3.2:1b by default
// Falls back to truncation if Ollama unavailable

Custom model:

const result = await rag({
  query: "python async patterns",
  contentMode: "summary",
  summaryModel: "mistral:7b"
})

Configuration via environment variables:

export OLLAMA_ENDPOINT=http://localhost:11434  # Default
export OLLAMA_MODEL=llama3.2:1b               # Default
export OLLAMA_TIMEOUT=30000                    # Default 30s

Fallback Behavior

  • ✅ Ollama unavailable → Automatic fallback to truncation

  • ✅ Model doesn't exist → Try default, then truncate

  • ✅ Timeout → Fallback to truncation

  • ✅ Zero configuration required - works out of the box

Recommended Models

Model

Size

Speed

Quality

Use Case

llama3.2:1b

1.3GB

⭐⭐⭐⭐⭐

⭐⭐⭐

✅ Recommended (default)

qwen2.5:0.5b

400MB

⭐⭐⭐⭐⭐

⭐⭐

Ultra-fast, lighter quality

mistral:7b

4GB

⭐⭐⭐

⭐⭐⭐⭐

Premium quality

Performance Comparison

Mode

Avg Tokens

Latency

Use Case

full

~20,000

3-5s

Complete research

preview

~6,000

3-5s

Quick scanning

summary

~1,500

4-8s*

Intelligent digests

* With Ollama. Falls back to preview performance if unavailable.

Phase 4: Resource Management

Control browser pool and memory usage to prevent system overload:

Environment Variables

Configure resource limits based on your system:

export MAX_BROWSERS=3          # Max concurrent browsers (default: 3)
export MAX_IDLE_TIME=30000     # Browser idle timeout in ms (default: 30s)
export MODEL_IDLE_TTL=300000   # Unload model after idle time in ms (default: 5min)

Make Configuration Permanent

macOS/Linux:

echo 'export MAX_BROWSERS=3' >> ~/.zshrc
echo 'export MAX_IDLE_TIME=30000' >> ~/.zshrc
echo 'export MODEL_IDLE_TTL=300000' >> ~/.zshrc
source ~/.zshrc

Windows (CMD):

setx MAX_BROWSERS 3
setx MAX_IDLE_TIME 30000
setx MODEL_IDLE_TTL 300000

Windows (PowerShell):

[Environment]::SetEnvironmentVariable("MAX_BROWSERS", "3", "User")
[Environment]::SetEnvironmentVariable("MAX_IDLE_TIME", "30000", "User")
[Environment]::SetEnvironmentVariable("MODEL_IDLE_TTL", "300000", "User")

Recommended Values by System

System RAM

MAX_BROWSERS

MAX_IDLE_TIME

MODEL_IDLE_TTL

4-8GB

2

20000

180000

8-16GB

3

30000

300000

16GB+

4

60000

600000

How It Works

  • Browser Pool: Reuses browser instances instead of creating/destroying per request

  • Idle Cleanup: Automatically closes idle browsers after MAX_IDLE_TIME

  • LLM Unload: Frees ~1-2GB RAM by unloading model after MODEL_IDLE_TTL of inactivity

Examples

Research workflow:

// 1. Quick scan with previews
const preview = await rag({
  query: "Next.js 14 features",
  contentMode: "preview",
  maxResults: 10
})

// 2. Get intelligent summary of top result
const summary = await rag({
  query: "Next.js 14 features",
  contentMode: "summary",
  maxResults: 1
})

// 3. Fetch full content for deep dive
const full = await fetchFullContent({
  contentHandle: preview.results[0].contentHandle
})

Troubleshooting:

Q: Summarization seems slow?

# Use faster model
ollama pull qwen2.5:0.5b
export OLLAMA_MODEL=qwen2.5:0.5b

Q: Getting truncated results instead of summaries?

# Check if Ollama is running
curl http://localhost:11434/api/tags

# If not running, start it
ollama serve

Local Development

Clone and Setup

macOS/Linux:

git clone https://github.com/alucardeht/isis-mcp.git
cd isis-mcp
npm install
npx playwright install chromium
npm run build

Windows (PowerShell):

git clone https://github.com/alucardeht/isis-mcp.git
cd isis-mcp
npm install
npx playwright install chromium
npm run build

Testing

macOS/Linux:

echo '{"jsonrpc":"2.0","id":1,"method":"tools/list"}' | node build/index.js

Windows (PowerShell):

@'
{"jsonrpc":"2.0","id":1,"method":"tools/list"}
'@ | node build/index.js

Windows (CMD):

echo {"jsonrpc":"2.0","id":1,"method":"tools/list"} | node build/index.js

Build Output

Compiled code is output to the build/ directory. Make sure to run npm run build after making changes to the source.

License

Licensed under the Apache License, Version 2.0. See the LICENSE file for full details.

You may obtain a copy of the License at:

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Available Tools

4 tools
fetchFullContentB

Busca conteúdo completo de um resultado anterior de RAG obtido em contentMode=preview

ParametersJSON Schema
NameRequiredDescriptionDefault
contentHandleYesHandle do conteúdo obtido em contentMode=preview da ferramenta rag
outputFormatNoFormato de saída do conteúdomarkdown

TDQS

B3.3/5.0
Behavior2/5

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 states the tool fetches full content, implying a read operation, but doesn't mention any behavioral traits like error handling, performance characteristics, or whether it requires specific permissions. For a tool with no annotation coverage, this is a significant gap, though it at least clarifies the operation type.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence in Portuguese that directly states the tool's purpose without any wasted words. It's appropriately sized and front-loaded, making it easy to understand quickly. Every part of the sentence earns its place by specifying the action, resource, and context.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's moderate complexity (2 parameters, no output schema, no annotations), the description is minimally adequate. It explains what the tool does and its context (post-RAG retrieval), but lacks details on output format, error cases, or integration with siblings. Without an output schema, it should ideally mention return values, but it doesn't, leaving gaps in completeness.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

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 both parameters thoroughly. The description adds no additional parameter semantics beyond what's in the schema (e.g., it doesn't explain 'contentHandle' further or provide examples). With high schema coverage, the baseline is 3, as the description doesn't compensate but doesn't detract either.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Busca conteúdo completo de um resultado anterior de RAG obtido em contentMode=preview' (Fetches full content from a previous RAG result obtained in contentMode=preview). It specifies the verb 'busca' (fetches) and the resource 'conteúdo completo' (full content), and distinguishes it from the sibling 'rag' tool by indicating it works on previous results from that tool. However, it doesn't explicitly differentiate from 'scrape' or 'screenshot' tools, keeping it at 4 rather than 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies when to use this tool: after obtaining a RAG result in contentMode=preview, to get the full content. It distinguishes from the 'rag' sibling by indicating this is for follow-up retrieval. However, it doesn't provide explicit alternatives or exclusions (e.g., when not to use it vs. 'scrape'), and no prerequisites are mentioned, so it's at an implied usage level.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

ragB

Busca web com extração inteligente de conteúdo (igual Apify RAG Web Browser)

ParametersJSON Schema
NameRequiredDescriptionDefault
queryYesTermo de busca para pesquisar na web
maxResultsNoMáximo de páginas a processar
outputFormatNoFormato de saída do conteúdomarkdown
contentModeNoModo de conteúdo: preview=resumo truncado (~300 chars), full=conteúdo completo, summary=sumarização inteligente via LLMfull
summaryModelNoModelo Ollama para sumarização (default: llama3.2:1b). Ex: mistral:7b, qwen2.5:0.5b
useJavascriptNoRenderizar JavaScript nas páginas
timeoutNoTimeout para scraping em milissegundos

TDQS

B3.1/5.0
Behavior2/5

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. While it mentions 'extração inteligente de conteúdo' and references Apify RAG Web Browser, it doesn't describe important behavioral traits like rate limits, authentication requirements, error handling, or what happens when JavaScript rendering is enabled. The description is insufficient for a tool with 7 parameters and complex functionality.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that immediately conveys the core functionality. It's appropriately sized and front-loaded with the essential information about what the tool does.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a complex web search and extraction tool with 7 parameters and no output schema, the description is incomplete. While concise, it doesn't explain what the tool returns, how results are structured, or provide context about the extraction intelligence. With no annotations and no output schema, more completeness would be expected for such a feature-rich tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

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 parameters thoroughly. The description adds no additional parameter semantics beyond what's in the schema. The baseline of 3 is appropriate when the schema does all the parameter documentation work.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool performs web search with intelligent content extraction, providing a specific verb ('Busca web') and resource ('conteúdo'). It distinguishes from siblings by mentioning 'extração inteligente de conteúdo' and referencing Apify RAG Web Browser, though it doesn't explicitly differentiate from fetchFullContent, scrape, or screenshot.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided about when to use this tool versus the sibling tools (fetchFullContent, scrape, screenshot). The description mentions it's similar to Apify RAG Web Browser, but this doesn't help an agent choose between available alternatives in this server.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

scrapeC

Extrai conteúdo inteligente de uma URL específica

ParametersJSON Schema
NameRequiredDescriptionDefault
urlYesURL da página para fazer scraping
selectorNoSeletor CSS para extrair elemento específico
javascriptNoRenderizar JavaScript antes de extrair
timeoutNoTimeout em milissegundos

TDQS

C2.9/5.0
Behavior2/5

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 mentions 'conteúdo inteligente' which hints at some processing beyond raw HTML, but doesn't specify what 'inteligente' means (e.g., text extraction, summarization, structured data). It lacks details on error handling, rate limits, authentication needs, or output format. For a web scraping tool with no annotation coverage, this is a significant gap.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence in Portuguese that directly states the tool's purpose. It's appropriately sized for a tool with clear parameters in the schema, with zero wasted words. The structure is front-loaded with the core functionality.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity of web scraping (network operations, potential failures, diverse outputs) and the absence of both annotations and an output schema, the description is insufficient. It doesn't explain what 'conteúdo inteligente' returns, how errors are handled, or any behavioral constraints. For a 4-parameter tool with no structured safety or output information, more descriptive context is needed.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

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 4 parameters thoroughly. The description adds no parameter-specific information beyond what's in the schema. It implies URL-based extraction but doesn't clarify parameter interactions or usage examples. With high schema coverage, the baseline is 3 even without additional param details in the description.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Extrai conteúdo inteligente de uma URL específica' clearly states the tool's purpose with a specific verb ('extrai') and resource ('conteúdo inteligente de uma URL específica'). It distinguishes from 'fetchFullContent' by implying intelligent extraction rather than full content retrieval, from 'rag' by focusing on web scraping rather than retrieval-augmented generation, and from 'screenshot' by extracting content rather than capturing images. However, it doesn't explicitly contrast with all siblings.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

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 like 'fetchFullContent', 'rag', or 'screenshot'. It doesn't mention prerequisites, constraints, or typical use cases. The agent must infer usage from the tool name and description alone without explicit direction.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

screenshotC

Captura screenshot de uma página web

ParametersJSON Schema
NameRequiredDescriptionDefault
urlYesURL da página para capturar
fullPageNoCapturar página inteira ou apenas viewport
widthNoLargura do viewport em pixels
heightNoAltura do viewport em pixels

TDQS

C2.9/5.0
Behavior2/5

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 the action ('captura') but doesn't mention critical traits such as whether it requires network access, potential rate limits, error handling, or the format of the output (e.g., image data). This leaves significant gaps in understanding how the tool behaves in practice.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence in Portuguese that directly states the tool's purpose without any wasted words. It's front-loaded and appropriately sized for a simple tool, making it easy to parse quickly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (a web screenshot tool with 4 parameters) and the absence of both annotations and an output schema, the description is incomplete. It doesn't address key contextual aspects like output format (e.g., image type), error conditions, or dependencies, leaving the agent with insufficient information for reliable use.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema description coverage is 100%, with clear descriptions for all parameters (e.g., 'URL da página para capturar'). The description adds no additional semantic context beyond what the schema provides, such as explaining interactions between parameters. This meets the baseline for high schema coverage but doesn't enhance understanding.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Captura screenshot de uma página web' clearly states the tool's purpose with a specific verb ('captura') and resource ('screenshot de uma página web'), making it immediately understandable. However, it doesn't differentiate from sibling tools like 'fetchFullContent' or 'scrape', which might also involve web content retrieval, so it doesn't reach the highest score.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

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 like 'fetchFullContent' or 'scrape'. It lacks explicit context, prerequisites, or exclusions, leaving the agent to infer usage based on the tool name alone, which is insufficient for optimal selection.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server
RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

B3.2/5.0
Disambiguation3/5

The tools have some overlap in purpose, particularly between 'rag' (web search with content extraction) and 'scrape' (extract content from a specific URL), which could cause confusion about when to use each. However, 'fetchFullContent' and 'screenshot' are more distinct, targeting specific retrieval and visual capture tasks, respectively.

Naming Consistency3/5

The naming conventions are mixed: 'fetchFullContent' uses camelCase, while 'rag', 'scrape', and 'screenshot' use lowercase. There is no consistent verb_noun pattern, but the names are still readable and descriptive of their functions.

Tool Count5/5

With 4 tools, the server is well-scoped for web content retrieval and extraction tasks. Each tool appears to serve a specific purpose without redundancy, making the count appropriate for the domain of web scraping, searching, and screenshot capture.

Completeness4/5

The tool set covers core web content operations: searching ('rag'), scraping from URLs ('scrape'), retrieving full content ('fetchFullContent'), and visual capture ('screenshot'). A minor gap might be the lack of tools for processing or analyzing the extracted content, but the basic retrieval and extraction workflows are well-covered.

Maintenance

ActivityInactive
ResponsivenessSyncing

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Related MCP Servers

  • crawl4ai-mcp-server

    amienbou121
    -
    license
    Not graded
    quality
    C
    maintenance
    Self-hosted MCP server that provides web scraping and crawling tools, integrating seamlessly with AI frameworks like OpenAI Agents SDK, Cursor, and Claude Code.
    4

  • web-basics-mcp

    yoloyash
    A
    license
    A
    quality
    A
    maintenance
    A self-hosted MCP server providing web search and URL fetching tools, running locally without external API keys or accounts.
    2
    538
    MIT

  • freecrawl

    RistrixOP
    F
    license
    Not graded
    quality
    C
    maintenance
    Open-source web scraping MCP server with anti-bot bypass, enabling AI models to scrape, crawl, search, and extract data from any website without API keys or limits.

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/alucardeht/isis-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server