Skip to main content
Glama
kky42

tinyfish-web-mcp

by kky42

tinyfish-web-mcp

A lean MCP server that gives any agent two tools, web_search and web_fetch, backed by TinyFish's Search and Fetch APIs. Both APIs are free at any wallet balance.

Unofficial. TinyFish also runs an official remote MCP server with around 15 tools, including paid browser automation. This server exposes only search and fetch, so it costs about 2 KB of tool schema in your agent's context.

Tools

web_search: searches the live web and returns up to 10 ranked results (title, URL, snippet). News results add date and publisher; research papers add authors, venue and citation count.

Input

Description

query (required)

Search keywords

domain_type

web (default), news, or research_paper

recency

hour, day, week, month or year: only results from that period

include_domains / exclude_domains

Arrays of domains to limit results to or exclude

web_fetch: reads 1–10 URLs as clean markdown, with JavaScript rendered.

Input

Description

urls (required)

URLs to read (1–10)

One call returns at most about 19 KiB of text, so it fits under client output limits (pi cuts MCP output at 20 KiB, Claude Code at about 25k tokens) and no page's file path gets cut. A single page shows up to about 19,000 characters inline (fewer for CJK text, which takes 3 bytes per character). When several URLs share a call, short pages are returned whole and the rest split what's left. A page that doesn't fit is downloaded once and saved in full to a markdown file under $TMPDIR/tinyfish-web-mcp/. Its result header gives the file path and an outline of the page's headings with line numbers, so the agent can Grep the file or Read just the section it needs, with no more network calls:

[truncated: showing lines 1–160 of 5295 (446095 chars). Full markdown saved to /tmp/tinyfish-web-mcp/2cb5….md — Grep it or Read a line range for the rest]
Outline (line: heading):
  25: ## 1. Introduction
  1214: ## 8. Representation Data and Metadata
  …

The note and outline sit before the page text, so they survive clients that truncate long tool output. The outline is capped at about 3,000 characters (deeper heading levels are dropped first). Lines longer than 1,000 characters are wrapped in the saved file so file-reading tools don't cut them. Saved files are private to the current user, re-fetching a URL overwrites its file, and every web_fetch call deletes files older than 24 hours and the oldest files beyond 100 MB in total.

Both tools return readable text plus structuredContent for scripts (for example pi's codemode): web_search gives results[{title, url, snippet, ...}], web_fetch gives pages[{url, title, text, total_chars, truncated?}] and errors. truncated is present only for long pages and holds {path, outline[{line, level, title}], omitted_headings, shown_lines, total_lines}. A call fails with isError: true when it errors, or when every URL of a web_fetch fails; clients that run tools from scripts get that as a normal result, so check isError. TinyFish returns no results for domain_type: "news" combined with exclude_domains, and rejects recency with research_paper.

Markdown conversion can alter structured data; for example, it escapes _ in JSON keys. Fetch JSON and raw files with a plain HTTP client instead.

Related MCP server: sofya-mcp

Install

Create an API key at agent.tinyfish.ai/api-keys. The server reads it from TINYFISH_API_KEY. Requires Node.js 20 or later.

Claude Code

claude mcp add tinyfish-web -s user -e TINYFISH_API_KEY=sk-tinyfish-... -- npx -y @kky42/tinyfish-web-mcp

Codex

codex mcp add tinyfish-web --env TINYFISH_API_KEY=sk-tinyfish-... -- npx -y @kky42/tinyfish-web-mcp

Other MCP clients (Cursor, Claude Desktop, and others that use this JSON format)

{
  "mcpServers": {
    "tinyfish-web": {
      "command": "npx",
      "args": ["-y", "@kky42/tinyfish-web-mcp"],
      "env": { "TINYFISH_API_KEY": "sk-tinyfish-..." }
    }
  }
}

Pi has built-in MCP support. Add this to ~/.pi/agent/mcp.json and run pi mcp list to check it. With the default exposure the tools are reached from codemode scripts as tools.mcp__tinyfish_web__web_search and tools.mcp__tinyfish_web__web_fetch; add "exposure": "direct" to declare them to the model like built-in tools.

{
  "mcpServers": {
    "tinyfish-web": {
      "command": "npx",
      "args": ["-y", "@kky42/tinyfish-web-mcp"]
    }
  }
}

If TINYFISH_API_KEY is exported in your shell, pi passes it to the server.

Development

npm install
npm run test:e2e   # build + real MCP client over stdio against the live TinyFish APIs (needs TINYFISH_API_KEY)

License

MIT

Available Tools

2 tools
web_fetchWeb FetchA
Read-only

Read web pages as clean markdown, with JavaScript rendered. Up to 10 URLs per call. Each URL returns at most 20000 characters; a truncated page's header gives the offset to continue from. Markdown conversion can alter structured data (e.g. it escapes _ in JSON keys), so fetch JSON or raw files with a plain HTTP client instead.

ParametersJSON Schema
NameRequiredDescriptionDefault
urlsYesURLs to read (1–10).
offsetNoCharacter position to start from, applied to every URL. Default 0. To continue a truncated page, use the offset from its header note.

TDQS

A4.9/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations only declare readOnlyHint and openWorldHint, so the description carries the rest and does it well: JS rendering, the 10-URL batch ceiling, the 20000-character per-URL cap, the truncation/offset continuation workflow, and a real behavioral caveat that markdown conversion mutates structured data such as underscores in JSON keys.

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?

Four sentences, each doing distinct work: capability, batch limit, per-URL limit plus continuation, and the misuse caveat. The core capability is front-loaded and nothing is redundant with the schema beyond necessary reinforcement.

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

Completeness5/5

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

With no output schema, the description still tells the agent what comes back (clean markdown per URL) and how to interpret and extend a partial result via the truncation header and offset. Nothing needed to invoke this correctly is missing.

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

Parameters4/5

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

Schema coverage is 100%, so a baseline of 3 applies, but the description goes beyond the schema by explaining the functional relationship between the two parameters: each URL is truncated at 20000 characters and the offset parameter is how you continue from the header note. That adds workflow meaning the schema fields only hint at.

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

Purpose5/5

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

States a specific verb+resource ('Read web pages as clean markdown, with JavaScript rendered') and immediately differentiates itself from the sibling web_search by describing a direct-read rather than discovery operation. An agent can tell which of the two tools to reach for without opening either schema.

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

Usage Guidelines5/5

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

The description gives an explicit when-not-to-use case plus the alternative: 'fetch JSON or raw files with a plain HTTP client instead', justified by markdown conversion escaping characters. That is a concrete routing rule with a stated reason, not just an implied context.

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.

  1. 2 tool updatesv0.1.0
    • First observedweb_fetch
    • First observedweb_search

TDQS

A4.4/5.0

Scored across 2 tools

Disambiguation5/5

web_search finds URLs while web_fetch reads them, with no overlap in purpose. The descriptions explicitly link them as a sequential workflow, making selection unambiguous.

Naming Consistency5/5

Both tools follow a clean web_<verb> snake_case pattern. There is no deviation or ambiguity in naming style.

Tool Count3/5

Two tools is thin for a general web-access server, even if they are powerful. The surface feels minimal, and the rubric treats 1-2 tools as borderline.

Completeness4/5

The search-and-fetch pair covers the core web retrieval lifecycle, including pagination via offset. Minor gaps exist, such as no dedicated extraction or structured-data tool, but the provided descriptions explain workarounds.

Maintenance

ActivityMaintained
ResponsivenessNo issues

Related MCP Connectors

Related MCP Servers

  • A
    license
    Not graded
    quality
    C
    maintenance
    Enables AI agents to perform query-driven web searches and fetch page content via Bing and DuckDuckGo engines, with automatic fallback and no API keys needed.
    MIT
  • A
    license
    A
    quality
    C
    maintenance
    Web tools for AI agents. Search the web for full page content, fetch URLs as clean markdown including PDFs, extract structured data from a page with a prompt, and run multi-source deep research that returns a cited report.
    4
    2
    MIT
  • F
    license
    Not graded
    quality
    D
    maintenance
    Enables AI agents to perform web searches, extract webpage content, and conduct end-to-end search-and-extract operations using multiple search providers and content extraction methods.
    -