outmate-gtm-router
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., "@outmate-gtm-routerFind HubSpot's pricing page and summarize its plans"
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.
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 ClaudeThe 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
Install the plugin through
/pluginor a marketplace. Claude Code will prompt for the two API keys because the manifest declares them as sensitiveuserConfigvalues. You can also run/plugin configure outmate-gtm-router@<marketplace>.For local development, you can instead copy
.env.exampleto.envin this plugin directory and add your keys..envtakes no precedence over environment variables passed by Claude Code.Install dependencies and compile:
npm install
npm run buildInclude 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.
Validate the Claude Code plugin:
claude plugin validate .Start Claude Code with this plugin loaded:
claude --plugin-dir /absolute/path/to/outmate-gtm-routerAlternatively, load it from the Plugin Manager or a marketplace after packaging/distribution is configured.
Inside Claude Code, run
/mcpand confirm theoutmate-gtm-routerserver 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
tavily_search
Arguments:
query(required): focused search query, 2–500 characters.maxResults(optional): 1–10, default 5.searchDepth(optional):basicoradvanced, defaultbasic.topic(optional):general,news, orfinance, defaultgeneral.timeRange(optional):day,week,month, oryear.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
.envfor development). They are never exposed as tool arguments or returned to Claude..envis 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 buildTo inspect the server independently of Claude Code, after building run:
npx @modelcontextprotocol/inspector node dist/index.jsDistribution
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 toolsjina_read_urlRead a webpage with JinaARead-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.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | Public HTTP or HTTPS webpage URL to read. |
Output Schema
| Name | Required | Description |
|---|---|---|
| url | Yes | |
| title | Yes | |
| content | Yes | |
| provider | Yes | |
| truncated | Yes | |
| description | Yes |
TDQS
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.
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.
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.
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.
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.
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.
tavily_searchSearch the web with TavilyARead-onlyIdempotent
Search the live web for company, product, market, competitor, prospect, technology, pricing, or news research. Use this tool to DISCOVER relevant webpages and source URLs. It returns ranked titles, URLs, snippets/content, and an optional short answer. Use jina_read_url when a specific result needs deeper page extraction. Do not use this tool to read a URL already known to the user.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Focused web search query. Include company/product name, geography, or date when relevant. | |
| topic | No | Search category. Use news for recent events and finance for financial/company-finance queries. | general |
| timeRange | No | Optional recency window for results. | |
| maxResults | No | Maximum number of search results to return. Default 5; maximum 10. | |
| searchDepth | No | Use basic for normal research; advanced for harder or more specific research. | basic |
| excludeDomains | No | Optional domains to exclude. | |
| includeDomains | No | Optional domains to restrict results to. |
Output Schema
| Name | Required | Description |
|---|---|---|
| query | Yes | |
| answer | Yes | |
| results | Yes | |
| provider | Yes | |
| truncated | Yes | |
| responseTime | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly, idempotent, open-world and non-destructive, so the safety profile is covered; the description usefully adds the return shape and routing behavior. The one loose end is the 'optional short answer', which no parameter exposes and which the description never explains, leaving ambiguity about whether extra synthesis is returned. No contradiction with annotations.
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?
Four short sentences, front-loaded with purpose, then return shape, then routing, then exclusion. The enumeration of research domains is slightly long but does real work in steering query intent.
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?
Since an output schema exists, return values need not be explained in depth, and the usage rules are fully covered. The only gap is the unexplained 'optional short answer' and the absence of any note on result limits/cost of advanced depth, which an agent would benefit from at call time.
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% with enums for topic, timeRange and searchDepth, so the parameters are already well documented. The description adds essentially no parameter-level guidance (e.g., when to favor searchDepth=advanced or how domain filters combine), so the baseline 3 applies.
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?
States a specific verb ('Search the live web') plus the resource domains and the intent ('DISCOVER relevant webpages and source URLs'). It also signals the return shape (ranked titles, URLs, snippets/content), which lets an agent distinguish it from jina_read_url 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.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives explicit when-to-use ('DISCOVER relevant webpages'), names the alternative for the other case ('Use jina_read_url when a specific result needs deeper page extraction'), and states a clear exclusion ('Do not use this tool to read a URL already known to the user'). Nothing is left to inference.
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.
2 tool updates
v0.1.0- First observed
jina_read_url - First observed
tavily_search
TDQS
Scored across 2 tools
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.
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.
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.
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
Related MCP Connectors
Jina AI Reader/Search MCP — turn any URL into clean LLM-ready markdown, plus web search.
Web search, scraping, RAG answers with citations, and translation as MCP tools.
Web data for agents. Extract web pages, crawl websites, discover URLs, and search the web.
Related MCP Servers
- FlicenseCqualityDmaintenanceEnables web search capabilities through the Tavily API. Allows users to search the web for information using natural language queries through the MCP protocol.3-
- FlicenseNot gradedqualityDmaintenanceProvides 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-
- AlicenseNot gradedqualityBmaintenanceJina AI Reader/Search MCP that turns any URL into clean LLM-ready markdown and provides web search.398 npmMIT
- AlicenseAqualityDmaintenanceEnables Claude to perform real-time web searches and fetch web page content via MCP, using OpenAI-compatible APIs with optional Tavily or Firecrawl engines.512 npm13MIT