Skip to main content
Glama
obhor

outmate-gtm-router

by obhor

Outmate — Intelligent GTM Router for Claude Code

By Outmate

A Claude Code plugin that exposes two read-only GTM research tools over MCP:

  • tavily_search — discover relevant web pages using Tavily Search.

  • jina_read_url — retrieve the readable content of a known public URL using Jina Reader.

Claude Code supplies the LLM and decides which MCP tool to invoke. The MCP server only validates arguments and executes the selected provider request; it has no LLM client of its own.

Architecture

User's natural-language request
              |
              v
       Claude Code (LLM)
   chooses the appropriate MCP tool
              |
              v
      Outmate MCP server
       (local stdio process)
          /       \
         v         v
   Tavily Search  Jina Reader
         \         /
          v       v
    Structured results to Claude

The plugin is deliberately local/stdio for Claude Code. Each user runs the MCP process locally and stores their own Tavily/Jina credentials in Claude Code plugin secure configuration. This is not yet a remotely hosted, multi-tenant MCP service. A hosted SaaS deployment should use Streamable HTTP, authentication, per-customer credential storage, and tenant isolation as a separate deployment target.

Related MCP server: Gemini Research MCP

Requirements

  • Claude Code v2.1.281 or later (plugin-declared MCP servers require this minimum; run claude --version).

  • Node.js 20.18 or later.

  • npm.

  • Tavily API key.

  • Jina API key.

Setup

  1. Install the plugin through /plugin or a marketplace. Claude Code will prompt for the two API keys because the manifest declares them as sensitive userConfig values. You can also run /plugin configure outmate-gtm-router@<marketplace>.

  2. For local development, you can instead copy .env.example to .env in this plugin directory and add your keys. .env takes no precedence over environment variables passed by Claude Code.

  3. Install dependencies and compile:

npm install
npm run build

Include the generated dist/ directory in the plugin release. Generate and commit package-lock.json before publishing to a marketplace. Claude Code installs Node dependencies automatically for marketplace-cached plugins when package.json and a supported npm lockfile are present. For a local directory install, run npm install and npm run build first.

  1. Validate the Claude Code plugin:

claude plugin validate .
  1. Start Claude Code with this plugin loaded:

claude --plugin-dir /absolute/path/to/outmate-gtm-router

Alternatively, load it from the Plugin Manager or a marketplace after packaging/distribution is configured.

  1. Inside Claude Code, run /mcp and confirm the outmate-gtm-router server is connected. If you have changed plugin files in an existing session, run /reload-plugins.

Example requests

  • "Research the latest funding news about Acme."

  • "Find the official pricing page for HubSpot and read it."

  • "Read https://example.com/pricing and summarize the plans."

  • "Compare the product positioning on these two public URLs: [URL A] and [URL B]."

Claude should use tavily_search to discover pages and jina_read_url to inspect selected pages in detail. Claude performs the reasoning and orchestration; the MCP server does not make a second LLM call.

Tool reference

Arguments:

  • query (required): focused search query, 2–500 characters.

  • maxResults (optional): 1–10, default 5.

  • searchDepth (optional): basic or advanced, default basic.

  • topic (optional): general, news, or finance, default general.

  • timeRange (optional): day, week, month, or year.

  • includeDomains / excludeDomains (optional): up to 10 domains.

jina_read_url

Arguments:

  • url (required): one public HTTP/HTTPS URL.

The server rejects local/private and reserved host patterns, URLs containing credentials, and nonstandard ports. It also resolves ordinary hostnames locally and rejects private/reserved DNS answers. This is defense in depth, not a substitute for a hardened URL-fetching proxy: Jina independently resolves and fetches the hostname, so DNS rebinding between checks cannot be eliminated by this client.

Security and operational behaviour

  • Provider keys are passed to the local MCP process from Claude Code's sensitive plugin configuration (or loaded from a local .env for development). They are never exposed as tool arguments or returned to Claude.

  • .env is git-ignored. Never commit provider keys.

  • MCP protocol messages use stdout. Application logs go to stderr only.

  • Requests have a timeout, one bounded retry on transient network/429/5xx errors, and a 16 MB provider-response size limit. Returned page text is separately truncated to the configured MCP output limit.

  • Search and page-read tools are marked read-only and idempotent.

  • Webpage content is untrusted input. Claude's skill instructs the model not to follow instructions embedded in retrieved pages.

  • Errors identify the provider and failure class without logging credentials or raw response headers.

Development

npm run dev
npm test
npm run build

To inspect the server independently of Claude Code, after building run:

npx @modelcontextprotocol/inspector node dist/index.js

Distribution

For a small internal test, share this plugin directory or a zip of it. Each recipient configures their own Tavily and Jina keys in the plugin configuration (or a local .env during development). The shared release must include dist/ and package-lock.json; do not include .env or node_modules/.

For a team marketplace, place this plugin under a marketplace repository's plugins/ directory and create a .claude-plugin/marketplace.json in the marketplace repository root. Do not put marketplace.json inside this plugin's .claude-plugin/ directory.

Current limitations

  • Two tools only: web search and public webpage reading.

  • No CRM integrations, write actions, OAuth user connections, billing, or multi-tenant account storage.

  • No automatic provider fallback: Tavily performs search; Jina reads a selected URL. They are complementary capabilities, not interchangeable providers.

  • No server-side LLM dependency; Claude Code owns all reasoning and orchestration.

  • The local plugin runs on the same machine/environment as Claude Code. A remote Streamable HTTP service is a separate deployment step.

Available Tools

2 tools
jina_read_urlRead a webpage with JinaA
Read-onlyIdempotent

Extract the readable content of one specific public webpage as LLM-friendly Markdown/text. Use this tool when the user supplies a URL or after tavily_search has found a relevant source that needs detailed inspection. This is a page-reading tool, not a search engine. It only accepts public HTTP/HTTPS URLs; never use it for localhost, private networks, or authenticated/private pages.

NameRequiredDescriptionDefault
urlYesPublic HTTP or HTTPS webpage URL to read.

Output Schema

NameRequiredDescription
urlYes
titleYes
contentYes
providerYes
truncatedYes
descriptionYes

TDQS

A4.7/5.0
Behavior4/5

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description adds real value beyond that by enumerating the input domains it refuses (localhost, private networks, authenticated pages), which the agent cannot infer from annotations alone. It stops short of mentioning rate limits, extraction failures, or truncation for huge pages.

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?

Three sentences, each doing distinct work: what it returns, when to call it, and what it rejects. The output format and the tool category come first, so the agent gets the essential distinction immediately.

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?

One required parameter, a full output schema (so return values need no prose), and annotations covering safety. The description supplies exactly the missing pieces: usage trigger and URL admissibility rules. Nothing needed to call it correctly is absent.

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% for the single 'url' parameter, so baseline would be 3. The description nevertheless adds constraints beyond the schema's 'Public HTTP or HTTPS webpage URL' by explicitly prohibiting localhost, private-network and authenticated URLs, tightening the meaning of a valid value.

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 and resource: 'Extract the readable content of one specific public webpage as LLM-friendly Markdown/text.' It explicitly disclaims search ('This is a page-reading tool, not a search engine'), which cleanly separates it from the sibling tavily_search.

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?

Gives both triggering conditions ('when the user supplies a URL' or 'after tavily_search has found a relevant source that needs detailed inspection') and hard exclusions (localhost, private networks, authenticated/private pages). The alternative is named and the condition selecting it is spelled out.

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 observedjina_read_url
    • First observedtavily_search

TDQS

A4.4/5.0

Scored across 2 tools

Disambiguation5/5

The two tools have clearly separate roles: tavily_search discovers web sources, while jina_read_url extracts content from a known URL. The descriptions explicitly cross-reference each other and warn against using one in place of the other, leaving no meaningful ambiguity.

Naming Consistency4/5

Both names use lowercase snake_case with a vendor prefix and an action-oriented second component. The pattern is mostly predictable, though jina_read_url includes an object ('url') while tavily_search does not, a minor inconsistency.

Tool Count3/5

Two tools is thin for a server named as a GTM router, even though the search-and-read pair is coherent. It is functional but borderline under-scoped for broader go-to-market research workflows.

Completeness4/5

The pair covers the core web-research lifecycle: discover relevant sources and then read a specific page. Minor gaps remain, such as batch reading or structured extraction, but no critical dead end is apparent for the stated purpose.

Maintenance

ActivityMaintained
ResponsivenessNo issues

Related MCP Connectors

Related MCP Servers

  • F
    license
    C
    quality
    D
    maintenance
    Enables web search capabilities through the Tavily API. Allows users to search the web for information using natural language queries through the MCP protocol.
    3
    -
  • F
    license
    Not graded
    quality
    D
    maintenance
    Provides real-time web research and URL summarization capabilities using Gemini 2.5 Flash with native Google Search grounding. It enables users to perform factual searches and summarize web content directly within MCP-compatible clients like Claude Desktop.
    17
    -
  • A
    license
    A
    quality
    D
    maintenance
    Enables Claude to perform real-time web searches and fetch web page content via MCP, using OpenAI-compatible APIs with optional Tavily or Firecrawl engines.
    5
    12 npm
    13
    MIT