tavily-automation
by ComposioHQtavily-automation helps agents run Tavily Web Research through Composio Rube MCP by discovering current tools with RUBE_SEARCH_TOOLS, checking the Tavily connection, and using live schemas before execution.
This skill scores 66/100, which means it is acceptable for directory listing but limited. Directory users get enough evidence to understand that it enables Tavily automation through Rube MCP and how an agent should start, but the listing should be treated as a lightweight connector workflow rather than a rich, task-specific automation package.
- Valid skill metadata clearly declares the required MCP dependency (`rube`) and a concise Tavily automation purpose.
- Provides concrete setup prerequisites: add `https://rube.app/mcp`, verify `RUBE_SEARCH_TOOLS`, manage the Tavily connection, and confirm ACTIVE status before use.
- Emphasizes tool discovery first, which should reduce schema guessing when Tavily tool definitions change.
- No support files, scripts, or reference examples are included; the skill is essentially a single MCP workflow guide.
- It does not document concrete Tavily use cases or expected outputs, so agents still depend heavily on RUBE_SEARCH_TOOLS and returned schemas at runtime.
Overview of tavily-automation skill
What tavily-automation does
tavily-automation is a Claude skill for running Tavily web research actions through Composio’s Rube MCP server. Instead of hard-coding Tavily tool names or stale schemas, the skill’s central rule is to call RUBE_SEARCH_TOOLS first, discover the current Tavily tools, then execute the task with the returned schema and execution guidance.
Best fit for Web Research workflows
The tavily-automation skill is best for users who want an agent to perform current web research, search-driven data gathering, source discovery, or Tavily-powered enrichment from inside an MCP-enabled client. It is especially useful when your workflow depends on live tool schemas, because the skill explicitly routes the agent through Rube’s tool discovery step before execution.
Key dependency to understand before install
This skill is not a standalone Tavily wrapper. It requires Rube MCP and an active Tavily connection managed through Composio. The repository’s SKILL.md lists requires: mcp: [rube], so adoption depends on whether your Claude or agent client can add https://rube.app/mcp as an MCP server and expose tools such as RUBE_SEARCH_TOOLS and RUBE_MANAGE_CONNECTIONS.
Main differentiator versus a generic prompt
A generic “use Tavily” prompt may fail when tool names, fields, or connection status are unknown. tavily-automation reduces that guesswork by enforcing a workflow: discover tools, verify the Tavily connection, use the discovered schema, execute, and adapt based on returned tool guidance.
How to Use tavily-automation skill
tavily-automation install and setup path
Install the skill from the repository path used by this directory:
npx skills add ComposioHQ/awesome-claude-skills --skill tavily-automation
Then configure Rube MCP in your client by adding:
https://rube.app/mcp
Before expecting useful output, confirm that RUBE_SEARCH_TOOLS is available. Next, use RUBE_MANAGE_CONNECTIONS with toolkit tavily and complete the returned authorization flow if the connection is not ACTIVE. Do not skip this step: most failures with tavily-automation are likely to be setup failures, not prompt failures.
Inputs the skill needs from you
Give the agent a concrete research job, not just a broad topic. Strong inputs include:
- the research question or decision you are trying to support
- target geography, date range, market, company, or domain
- required output format, such as table, source list, brief, or JSON
- source preferences or exclusions
- freshness requirements, such as “published in the last 30 days”
- how many results or sources you need
Weak prompt: “Research AI search tools.”
Stronger prompt: “Use tavily-automation for Web Research to find current AI search APIs for enterprise research workflows. Prioritize official docs and pricing pages, exclude opinion-only blog posts, and return a comparison table with product, API capability, pricing signal, source URL, and last-accessed note.”
Practical tavily-automation usage workflow
A good tavily-automation usage pattern is:
- Ask the agent to call
RUBE_SEARCH_TOOLSfor your specific Tavily task. - Have it inspect returned tool slugs, input schemas, execution plans, and known pitfalls.
- Ask it to check the Tavily connection with
RUBE_MANAGE_CONNECTIONS. - Run the Tavily operation only after the connection is active.
- Request citations, URLs, and a short explanation of how results were filtered.
- Iterate with narrower follow-up searches if the first result set is too broad.
This matters because Rube can return current schemas and recommended plans. If you tell the model to guess field names, you lose the main benefit of the skill.
Repository files to read first
The upstream skill currently consists mainly of SKILL.md under composio-skills/tavily-automation. Read that file first because it contains the prerequisites, Rube MCP endpoint, connection workflow, and required “search tools first” behavior. There are no visible supporting scripts/, references/, resources/, or rules/ folders in the provided tree, so treat SKILL.md as the authoritative operating guide.
tavily-automation skill FAQ
Is tavily-automation suitable for beginners?
Yes, if you are comfortable adding an MCP server and following an auth link for the Tavily connection. It is less beginner-friendly if your client does not clearly show available MCP tools, because the skill depends on seeing and calling RUBE_SEARCH_TOOLS and RUBE_MANAGE_CONNECTIONS.
When should I not use tavily-automation?
Do not use tavily-automation for offline analysis, private document review, or tasks where live web search is unnecessary. Also avoid it if your environment cannot use Rube MCP, if external web access is restricted, or if you need a fully local research stack with no third-party tool connection.
How is it different from calling Tavily directly?
Direct Tavily integrations usually require you to know the API, authentication, and request schema. tavily-automation delegates the available-tool discovery and connection handling to Rube MCP through Composio. That makes it convenient for agent workflows, but also means you are operating through the Rube/Composio tool layer rather than a hand-coded Tavily API client.
Does the skill guarantee accurate research results?
No. It helps the agent discover and run Tavily tools correctly, but search results still need review. Ask for source URLs, publication dates when available, and a separation between verified facts and model interpretation. For high-stakes work, use tavily-automation as a research accelerator, not as the final authority.
How to Improve tavily-automation skill
Improve tavily-automation prompts with sharper scope
The fastest way to improve tavily-automation output is to constrain the research task. Replace vague goals with search-ready instructions: audience, market, recency, source type, exclusions, and final format. For example, “find recent regulatory updates affecting fintech KYC in the EU” is much easier to execute than “research fintech rules.”
Common failure modes to watch
The most common failure is skipping tool discovery. If the agent tries to call a Tavily tool before RUBE_SEARCH_TOOLS, redirect it. Another failure is running before the Tavily connection is active; verify with RUBE_MANAGE_CONNECTIONS. A third failure is accepting broad results without refinement. Use follow-up searches when sources are outdated, off-topic, duplicated, or too promotional.
Iterate after the first output
After the first Tavily run, ask the agent to classify gaps: missing regions, weak sources, outdated pages, or unanswered subquestions. Then run a second targeted query using the same session when appropriate. Good iteration prompts include “search only official documentation,” “find contrary evidence,” “limit to 2024-2026 sources,” or “expand with competitor pricing pages.”
What maintainers could add next
The tavily-automation skill would become easier to adopt with a short example prompt library, sample RUBE_SEARCH_TOOLS requests for common Web Research jobs, and troubleshooting notes for inactive Tavily connections. A small checklist for output quality—citations, dates, deduplication, and confidence notes—would also help users get more reliable research results without reading external toolkit docs first.