Skip to main content
Glama
yigitkonur

Research Powerpack MCP

by yigitkonur
OverviewSchemaRelated ServersScoreDiscussions
TypeScript
Remote

🧭 Quick Navigation

⚡ Get Started • ✨ Key Features • 🎮 Usage & Examples • ⚙️ API Key Setup • 🆚 Why This Slaps

research-powerpack-mcp is the research assistant your AI wishes it had. Stop asking your LLM to guess about things it doesn't know. This MCP server acts like a senior researcher, searching the web, mining Reddit discussions, scraping documentation, and synthesizing everything into perfectly structured context so your AI can actually give you answers worth a damn.

How it slaps:

  • You: "What's the best database for my use case?"

  • AI + Powerpack: Searches Google, mines Reddit threads, scrapes docs, synthesizes findings.

  • You: Get an actually informed answer with real community opinions and citations.

  • Result: Ship better decisions. Skip the 47 browser tabs.

💥 Why This Slaps Other Methods

Manually researching is a vibe-killer. research-powerpack-mcp makes other methods look ancient.

We're not just fetching random pages. We're building high-signal, low-noise context with CTR-weighted ranking, smart comment allocation, and intelligent token distribution that prevents massive responses from breaking your LLM's context window.

🚀 Get Started in 60 Seconds

1. Install

npm install research-powerpack-mcp

2. Configure Your MCP Client

Client

Config File

Docs

🖥️ Claude Desktop

claude_desktop_config.json

Setup

⌨️ Claude Code

~/.claude.json or CLI

Setup

🎯 Cursor

.cursor/mcp.json

Setup

🏄 Windsurf

MCP settings

Setup

Claude Desktop

Add to your claude_desktop_config.json:

{
  "mcpServers": {
    "research-powerpack": {
      "command": "npx",
      "args": ["research-powerpack-mcp"],
      "env": {
        "SERPER_API_KEY": "your_key",
        "REDDIT_CLIENT_ID": "your_id",
        "REDDIT_CLIENT_SECRET": "your_secret",
        "SCRAPEDO_API_KEY": "your_key",
        "OPENROUTER_API_KEY": "your_key"
      }
    }
  }
}

or quick install (for MacOS):

cat ~/Library/Application\ Support/Claude/claude_desktop_config.json | jq '.mcpServers["research-powerpack"] = {
  "command": "npx",
  "args": ["research-powerpack-mcp@latest"],
  "disabled": false,
  "env": {
    "OPENROUTER_API_KEY": "xxx",
    "REDDIT_CLIENT_ID": "xxx",
    "REDDIT_CLIENT_SECRET": "xxx",
    "RESEARCH_MODEL": "xxxx",
    "SCRAPEDO_API_KEY": "xxx",
    "SERPER_API_KEY": "xxxx"
  }
}' | tee ~/Library/Application\ Support/Claude/claude_desktop_config.json

Claude Code (CLI)

One command to rule them all:

claude mcp add research-powerpack npx \
  --scope user \
  --env SERPER_API_KEY=your_key \
  --env REDDIT_CLIENT_ID=your_id \
  --env REDDIT_CLIENT_SECRET=your_secret \
  --env OPENROUTER_API_KEY=your_key \
  --env OPENROUTER_BASE_URL=https://openrouter.ai/api/v1 \
  --env RESEARCH_MODEL=x-ai/grok-4.1-fast \
  -- research-powerpack-mcp

Or manually add to ~/.claude.json:

{
  "mcpServers": {
    "research-powerpack": {
      "command": "npx",
      "args": ["research-powerpack-mcp"],
      "env": {
        "SERPER_API_KEY": "your_key",
        "REDDIT_CLIENT_ID": "your_id",
        "REDDIT_CLIENT_SECRET": "your_secret",
        "OPENROUTER_API_KEY": "your_key",
        "OPENROUTER_BASE_URL": "https://openrouter.ai/api/v1",
        "RESEARCH_MODEL": "x-ai/grok-4.1-fast"
      }
    }
  }
}

Cursor/Windsurf

Add to .cursor/mcp.json or equivalent:

{
  "mcpServers": {
    "research-powerpack": {
      "command": "npx",
      "args": ["research-powerpack-mcp"],
      "env": {
        "SERPER_API_KEY": "your_key"
      }
    }
  }
}

✨ Zero Crash Promise: Missing API keys? No problem. The server always starts. Tools just return helpful setup instructions instead of exploding.

✨ Feature Breakdown: The Secret Sauce

Feature

What It Does

Why You Care

🔍 Batch Search100 keywords parallel

Search Google for up to 100 queries simultaneously

Cover every angle of a topic in one shot

📊 CTR RankingSmart URL scoring

Identifies URLs that appear across multiple searches

Surfaces high-consensus authoritative sources

💬 Reddit MiningReal human opinions

Google-powered Reddit search + native API fetching

Get actual user experiences, not marketing fluff

🎯 Smart AllocationToken-aware budgets

1,000 comment budget distributed across posts

Deep dive on 2 posts or quick scan on 50

🌐 Universal ScrapingWorks on everything

Auto-fallback: basic → JS render → geo-targeting

Handles SPAs, paywalls, and geo-restricted content

🧠 Deep ResearchAI-powered synthesis

Batch research with web search and citations

Get comprehensive answers to complex questions

🧩 Modular DesignUse what you need

Each tool works independently

Pay only for the APIs you actually use

🎮 Tool Reference

web_search

Batch web search using Google via Serper API. Search up to 100 keywords in parallel.

Parameter

Type

Required

Description

keywords

string[]

Yes

Search queries (1-100). Use distinct keywords for maximum coverage.

Supports Google operators: site:, -exclusion, "exact phrase", filetype:

{
  "keywords": [
    "best IDE 2025",
    "VS Code alternatives",
    "Cursor vs Windsurf comparison"
  ]
}

search_reddit

Search Reddit via Google with automatic site:reddit.com filtering.

Parameter

Type

Required

Description

queries

string[]

Yes

Search queries (max 10)

date_after

string

No

Filter results after date (YYYY-MM-DD)

Search operators: intitle:keyword, "exact phrase", OR, -exclude

{
  "queries": [
    "best mechanical keyboard 2025",
    "intitle:keyboard recommendation"
  ],
  "date_after": "2024-01-01"
}

get_reddit_post

Fetch Reddit posts with smart comment allocation (1,000 comment budget distributed automatically).

Parameter

Type

Required

Default

Description

urls

string[]

Yes

—

Reddit post URLs (2-50)

fetch_comments

boolean

No

true

Whether to fetch comments

max_comments

number

No

auto

Override comment allocation

Smart Allocation:

  • 2 posts → ~500 comments/post (deep dive)

  • 10 posts → ~100 comments/post

  • 50 posts → ~20 comments/post (quick scan)

{
  "urls": [
    "https://reddit.com/r/programming/comments/abc123/post_title",
    "https://reddit.com/r/webdev/comments/def456/another_post"
  ]
}

scrape_links

Universal URL content extraction with automatic fallback modes.

Parameter

Type

Required

Default

Description

urls

string[]

Yes

—

URLs to scrape (3-50)

timeout

number

No

30

Timeout per URL (seconds)

use_llm

boolean

No

false

Enable AI extraction

what_to_extract

string

No

—

Extraction instructions for AI

Automatic Fallback: Basic → JS rendering → JS + US geo-targeting

{
  "urls": ["https://example.com/article1", "https://example.com/article2"],
  "use_llm": true,
  "what_to_extract": "Extract the main arguments and key statistics"
}

deep_research

AI-powered batch research with web search and citations.

Parameter

Type

Required

Description

questions

object[]

Yes

Research questions (2-10)

questions[].question

string

Yes

The research question

questions[].file_attachments

object[]

No

Files to include as context

Token Allocation: 32,000 tokens distributed across questions:

  • 2 questions → 16,000 tokens/question (deep dive)

  • 10 questions → 3,200 tokens/question (rapid multi-topic)

{
  "questions": [
    { "question": "What are the current best practices for React Server Components in 2025?" },
    { "question": "Compare Bun vs Node.js for production workloads with benchmarks." }
  ]
}

⚙️ Environment Variables & Tool Availability

Research Powerpack uses a modular architecture. Tools are automatically enabled based on which API keys you provide:

ENV Variable

Tools Enabled

Free Tier

SERPER_API_KEY

web_search, search_reddit

2,500 queries/mo

REDDIT_CLIENT_ID + SECRET

get_reddit_post

Unlimited

SCRAPEDO_API_KEY

scrape_links

1,000 credits/mo

OPENROUTER_API_KEY

deep_research + AI in scrape_links

Pay-as-you-go

RESEARCH_MODEL

Model for deep_research

Default: perplexity/sonar-deep-research

LLM_EXTRACTION_MODEL

Model for AI extraction in scrape_links

Default: openrouter/gpt-oss-120b:nitro

Configuration Examples

# Search-only mode (just web_search and search_reddit)
SERPER_API_KEY=xxx

# Reddit research mode (search + fetch posts)
SERPER_API_KEY=xxx
REDDIT_CLIENT_ID=xxx
REDDIT_CLIENT_SECRET=xxx

# Full research mode (all 5 tools)
SERPER_API_KEY=xxx
REDDIT_CLIENT_ID=xxx
REDDIT_CLIENT_SECRET=xxx
SCRAPEDO_API_KEY=xxx
OPENROUTER_API_KEY=xxx

🔑 API Key Setup Guides

What you get

  • Fast Google search results via API

  • Enables web_search and search_reddit tools

Setup Steps

  1. Go to serper.dev

  2. Click "Get API Key" (top right)

  3. Sign up with email or Google

  4. Copy your API key from the dashboard

  5. Add to your config:

    SERPER_API_KEY=your_key_here

Pricing

  • Free: 2,500 queries/month

  • Paid: $50/month for 50,000 queries

What you get

  • Full Reddit API access

  • Fetch posts and comments with upvote sorting

  • Enables get_reddit_post tool

Setup Steps

  1. Go to reddit.com/prefs/apps

  2. Scroll down and click "create another app..."

  3. Fill in:

    • Name: research-powerpack (or any name)

    • App type: Select "script" (important!)

    • Redirect URI: http://localhost:8080

  4. Click "create app"

  5. Copy your credentials:

    • Client ID: The string under your app name

    • Client Secret: The "secret" field

  6. Add to your config:

    REDDIT_CLIENT_ID=your_client_id
REDDIT_CLIENT_SECRET=your_client_secret

What you get

  • JavaScript rendering support

  • Geo-targeting and CAPTCHA handling

  • Enables scrape_links tool

Setup Steps

  1. Go to scrape.do

  2. Click "Start Free"

  3. Sign up with email

  4. Copy your API key from the dashboard

  5. Add to your config:

    SCRAPEDO_API_KEY=your_key_here

Credit Usage

  • Basic scrape: 1 credit

  • JavaScript rendering: 5 credits

  • Geo-targeting: +25 credits

What you get

  • Access to 100+ AI models via one API

  • Enables deep_research tool

  • Enables AI extraction in scrape_links

Setup Steps

  1. Go to openrouter.ai

  2. Sign up with Google/GitHub/email

  3. Go to openrouter.ai/keys

  4. Click "Create Key"

  5. Copy the key (starts with sk-or-...)

  6. Add to your config:

    OPENROUTER_API_KEY=sk-or-v1-xxxxx

Recommended Models for Deep Research

# Default (optimized for research)
RESEARCH_MODEL=perplexity/sonar-deep-research

# Fast and capable
RESEARCH_MODEL=x-ai/grok-4.1-fast

# High quality
RESEARCH_MODEL=anthropic/claude-3.5-sonnet

# Budget-friendly
RESEARCH_MODEL=openai/gpt-4o-mini

Recommended Models for AI Extraction (use_llm in scrape_links)

# Default (fast and cost-effective for extraction)
LLM_EXTRACTION_MODEL=openrouter/gpt-oss-120b:nitro

# High quality extraction
LLM_EXTRACTION_MODEL=anthropic/claude-3.5-sonnet

# Budget-friendly
LLM_EXTRACTION_MODEL=openai/gpt-4o-mini

Note: RESEARCH_MODEL and LLM_EXTRACTION_MODEL are independent. You can use a powerful model for deep research and a faster/cheaper model for content extraction, or vice versa.

🔥 Recommended Workflows

Research a Technology Decision

1. web_search → ["React vs Vue 2025", "Next.js vs Nuxt comparison"]
2. search_reddit → ["best frontend framework 2025", "Next.js production experience"]
3. get_reddit_post → [URLs from step 2]
4. scrape_links → [Documentation and blog URLs from step 1]
5. deep_research → [Synthesize findings into specific questions]

Competitive Analysis

1. web_search → ["competitor name review", "competitor vs alternatives"]
2. scrape_links → [Competitor websites, review sites]
3. search_reddit → ["competitor name experience", "switching from competitor"]
4. get_reddit_post → [URLs from step 3]

Debug an Obscure Error

1. web_search → ["exact error message", "error + framework name"]
2. search_reddit → ["error message", "framework + error type"]
3. get_reddit_post → [URLs with solutions]
4. scrape_links → [Stack Overflow answers, GitHub issues]

🔥 Enable Full Power Mode

For the best research experience, configure all four API keys:

SERPER_API_KEY=your_serper_key       # Free: 2,500 queries/month
REDDIT_CLIENT_ID=your_reddit_id       # Free: Unlimited
REDDIT_CLIENT_SECRET=your_reddit_secret
SCRAPEDO_API_KEY=your_scrapedo_key   # Free: 1,000 credits/month
OPENROUTER_API_KEY=your_openrouter_key # Pay-as-you-go

This unlocks:

  • 5 research tools working together

  • AI-powered content extraction in scrape_links

  • Deep research with web search and citations

  • Complete Reddit mining (search → fetch → analyze)

Total setup time: ~10 minutes. Total free tier value: ~$50/month equivalent.

🛠️ Development

# Clone
git clone https://github.com/yigitkonur/research-powerpack-mcp.git
cd research-powerpack-mcp

# Install
npm install

# Development
npm run dev

# Build
npm run build

# Type check
npm run typecheck

🏗️ Architecture (v3.4.0+)

The codebase uses a YAML-driven configuration system with aggressive LLM optimization (v3.5.0+):

Core Architecture

Component

File

Purpose

Tool Definitions

src/config/yaml/tools.yaml

Single source of truth for all tool metadata

Handler Registry

src/tools/registry.ts

Declarative tool registration + executeTool wrapper

YAML Loader

src/config/loader.ts

Parses YAML, generates MCP-compatible definitions (cached)

Concurrency Utils

src/utils/concurrency.ts

Bounded parallel execution (pMap/pMapSettled)

Shared Utils

src/tools/utils.ts

Common utility functions

Adding a new tool:

  1. Add tool definition to tools.yaml

  2. Create handler in src/tools/

  3. Register in src/tools/registry.ts

See docs/refactoring/04-migration-guide.md for detailed instructions.

Performance & Stability (v3.5.1+)

All parallel operations use bounded concurrency to prevent CPU spikes and API rate limits:

Operation

Before

After

Reddit search queries

50 concurrent

8 concurrent

Web scraping batches

30 concurrent

10 concurrent

Deep research questions

Unbounded

3 concurrent

Reddit post fetching

10 concurrent

5 concurrent

File attachments

Unbounded

5 concurrent

Additional optimizations:

  • YAML config cached in memory (no repeated disk reads)

  • Async file I/O (no event loop blocking)

  • Pre-compiled regex patterns for hot paths

  • Reddit auth token deduplication (prevents concurrent token requests)

LLM Optimization (v3.5.0+)

All tools include aggressive guidance to force LLMs to use them optimally:

Feature

Description

Configurable Limits

All min/max values in YAML (limits section)

BAD vs GOOD Examples

Every tool shows anti-patterns and perfect usage

Aggressive Phrasing

Changed from "you can" to "you MUST"

Visual Formatting

Emoji headers, section dividers, icons for visual scanning

Templates

Structured formats for questions, extractions, file descriptions

Key Enhancements:

  • search_reddit: Minimum 10 queries (was 3), 10-category formula

  • deep_research: 7-section question template, file attachment requirements

  • scrape_links: Extraction template with OR statements, use_llm=true push

  • web_search: Minimum 3 keywords, search operator examples

  • file_attachments: Numbered 5-section description template

See docs/refactoring/07-llm-optimization-summary.md for full details.

🔥 Common Issues & Quick Fixes

Problem

Solution

Tool returns "API key not configured"

Add the required ENV variable to your MCP config. The error message tells you exactly which key is missing.

Reddit posts returning empty

Check your REDDIT_CLIENT_ID and REDDIT_CLIENT_SECRET. Make sure you created a "script" type app.

Scraping fails on JavaScript sites

This is expected for first attempt. The tool auto-retries with JS rendering. If still failing, the site may be blocking scrapers.

Deep research taking too long

Use a faster model like x-ai/grok-4.1-fast instead of perplexity/sonar-deep-research.

Token limit errors

Reduce the number of URLs/questions per request. The tool distributes a fixed token budget.

Built with 🔥 because manually researching for your AI is a soul-crushing waste of time.

MIT © Yiğit Konur

Available Tools

5 tools
deep_researchA

🔥 DEEP RESEARCH - 2-10 QUESTIONS, RECOMMENDED 5+

This tool runs 2-10 questions IN PARALLEL with AI-powered research. Using 1-2 questions = wasting the parallel research capability!

Token Budget: 32,000 tokens distributed across questions.

  • 2 questions: 16,000 tokens each (deep dive)

  • 5 questions: 6,400 tokens each (RECOMMENDED: balanced)

  • 10 questions: 3,200 tokens each (comprehensive multi-topic)

All questions research in PARALLEL - no time penalty for more questions!

When to use this tool:

  • Multi-perspective analysis on related topics

  • Researching a domain from multiple angles

  • Validating understanding across different aspects

  • Comparing approaches/technologies side-by-side

  • Deep technical questions requiring comprehensive research

Question Template - Each question MUST include these sections:

  1. 🎯 WHAT I NEED: Clearly state what you're trying to achieve or understand

  2. 🤔 WHY I'M RESEARCHING: What decision does this inform? What problem are you solving?

  3. 📚 WHAT I ALREADY KNOW: Share current understanding so research fills gaps, not repeats basics

  4. 🔧 HOW I'LL USE THIS: Practical application - implementation, debugging, architecture

  5. ❓ SPECIFIC QUESTIONS (2-5): Break down into specific, pointed sub-questions

  6. 🌐 PRIORITY SOURCES: (optional) Preferred docs/sites to prioritize

  7. ⚡ FOCUS AREAS: (optional) What matters most - performance, security, etc.

ATTACH FILES when asking about code - THIS IS MANDATORY:

  • 🐛 Bugs/errors → Attach the failing code

  • ⚡ Performance issues → Attach the slow code paths

  • ♻️ Refactoring → Attach current implementation

  • 🔍 Code review → Attach code to review

  • 🏗️ Architecture → Attach relevant modules

Research without code context for code questions is generic and unhelpful!

Example: ❌ BAD: {"questions": [{"question": "Research React hooks"}]} → 1 vague question, no template, no context, wastes 90% capacity

✅ GOOD: 

{"questions": [{
  "question": "🎯 WHAT I NEED: Understand when to use useCallback vs useMemo in React 18\n\n🤔 WHY: Optimizing a data-heavy dashboard with 50+ components, seeing performance issues\n\n📚 WHAT I KNOW: Both memoize values, useCallback for functions, useMemo for computed values. Unclear when each actually prevents re-renders.\n\n🔧 HOW I'LL USE THIS: Refactor Dashboard.tsx to eliminate unnecessary re-renders\n\n❓ SPECIFIC QUESTIONS:\n1. When does useCallback actually prevent re-renders vs when it doesn't?\n2. Performance benchmarks: useCallback vs useMemo vs neither in React 18?\n3. Common anti-patterns that negate their benefits?\n4. How to measure if they're actually helping?\n\n🌐 PRIORITY: Official React docs, React team blog posts\n⚡ FOCUS: Patterns for frequently updating state"
}, ...add 4 more questions for comprehensive coverage]}

Pro Tips:

  1. Use 5-10 questions - Maximize parallel research capacity

  2. Follow the template - Include all 7 sections for each question

  3. Be specific - Include version numbers, error codes, library names

  4. Add 2-5 sub-questions - Break down what you need to know

  5. Attach files for code questions - MANDATORY for bugs/performance/refactoring

  6. Describe files thoroughly - Explain what the file is and what to focus on

  7. Specify focus areas - "Focus on X, Y, Z" for prioritization

  8. Group related questions - Research a domain from multiple angles

Scope Expansion Triggers - Iterate when:

  • Results mention concepts you didn't research

  • Answers raise new questions you should explore

  • You realize initial scope was too narrow

  • You discover related topics that matter

Workflow: deep_research (3-5 questions) → sequentialthinking (evaluate, identify gaps) → OPTIONAL: deep_research AGAIN with NEW questions based on learnings → sequentialthinking (synthesize) → final decision

REMEMBER:

  • ALWAYS think after getting results (digest and identify gaps!)

  • DON'T assume first research is complete (iterate based on findings!)

  • USE learnings to ask better questions (results = feedback!)

  • EXPAND scope when results reveal new important areas!

ParametersJSON Schema
NameRequiredDescriptionDefault
questionsYes**Batch deep research (2-10 questions) with dynamic token allocation.** **TOKEN BUDGET:** 32,000 tokens distributed across all questions: - 2 questions: 16,000 tokens/question (deep dive) - 5 questions: 6,400 tokens/question (balanced) - 10 questions: 3,200 tokens/question (rapid multi-topic) **WHEN TO USE:** - Need multi-perspective analysis on related topics - Researching a domain from multiple angles - Validating understanding across different aspects - Comparing approaches/technologies side-by-side **EACH QUESTION SHOULD INCLUDE:** - Topic & context (what decision it informs) - Your current understanding (to fill gaps) - Specific sub-questions (2-5 per topic) **USE:** Maximize question count for comprehensive coverage. All questions run in parallel. Group related questions for coherent research.

TDQS

A4.7/5.0
Behavior4/5

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

With no annotations, the description carries the full burden. It explains parallel execution, token distribution (32,000 total), and mandatory file attachments for code questions. However, it does not explicitly state failure modes (e.g., token overrun) or output format, leaving minor gaps.

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

Conciseness4/5

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

The description is long but well-organized with headings, bullet points, examples, and pro tips. It front-loads key information (parallelism, recommended count) and uses markdown for clarity. Some redundancy (e.g., 'recommended 5+' is repeated) could be trimmed without losing substance.

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?

Given the tool's complexity (batch research, token budget, file attachments) and absence of output schema, the description covers input format, usage constraints, file attachment requirements, and iterative workflow. It includes comprehensive examples and edge cases (e.g., scope expansion triggers).

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

Parameters5/5

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

Schema coverage is 100%, so baseline is 3, but the description vastly enriches the single parameter (questions) with a detailed structured template, examples, file attachment guidance, and token allocation details. This goes well beyond the schema's own description.

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?

The description clearly states the tool runs 2-10 questions in parallel for AI-powered research, and distinguishes it from sibling tools (e.g., web_search, search_reddit) by focusing on multi-perspective, batch research with a shared token budget.

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 provides explicit when-to-use scenarios (multi-perspective analysis, domain research from multiple angles) and includes a suggested workflow with sequentialthinking. It also gives concrete examples and recommends 5-10 questions to maximize capacity.

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

get_reddit_postA

🔥 FETCH REDDIT POSTS - 2-50 URLs, RECOMMENDED 10-20+

This tool fetches Reddit posts with smart comment allocation. Using 2-5 posts = missing community consensus. Use 10-20+ for broad perspective.

Comment Budget: 1,000 total comments distributed automatically across posts.

  • 2 posts: ~500 comments/post (deep dive)

  • 10 posts: ~100 comments/post (balanced)

  • 20 posts: ~50 comments/post (RECOMMENDED: broad)

  • 50 posts: ~20 comments/post (max coverage)

Comment allocation is AUTOMATIC - you don't need to calculate!

When to use different post counts:

2-5 posts: Deep dive on specific discussions

  • Use when: You found THE perfect thread and want all comments

  • Trade-off: Deep but narrow perspective

10-15 posts: Balanced depth + breadth (GOOD)

  • Use when: Want good comment depth across multiple discussions

  • Trade-off: Good balance of depth and coverage

20-30 posts: Broad community perspective (RECOMMENDED)

  • Use when: Want to see consensus across many discussions

  • Trade-off: Less comments per post but more diverse opinions

40-50 posts: Maximum coverage

  • Use when: Researching controversial topic, need all perspectives

  • Trade-off: Fewer comments per post but comprehensive coverage

Example: ❌ BAD: {"urls": ["single_url"]} → 1 perspective, could be biased/outdated ✅ GOOD: {"urls": [20 URLs from diverse subreddits: programming, webdev, node, golang, devops, etc.]} → comprehensive community perspective

Pro Tips:

  1. Use 10-20+ posts - More posts = broader community perspective

  2. Mix subreddits - Different communities have different expertise and perspectives

  3. Include various discussion types - Best practices, comparisons, problems, solutions

  4. Let comment allocation auto-adjust - Don't override max_comments unless needed

  5. Use after search_reddit - Get URLs from search, then fetch full content here

CRITICAL: Comments often contain the BEST insights, solutions, and real-world experiences. Always set fetch_comments=true unless you only need post titles.

Workflow: search_reddit (find posts) → get_reddit_post (fetch full content + comments)

ParametersJSON Schema
NameRequiredDescriptionDefault
urlsYes**2-50 Reddit post URLs** (Minimum 2, recommended 10-20) More posts = broader community perspective and better consensus detection. Get URLs from search_reddit results, then fetch full content here.
use_llmNo**Enable AI-powered content extraction (RECOMMENDED: true)** When enabled, processes Reddit content through LLM to: - Extract key insights and community consensus - Synthesize opinions across multiple posts - Identify common recommendations and debates - Filter noise and surface actionable information Cost: pennies (~$0.01 per batch) Requires: OPENROUTER_API_KEY environment variable
max_commentsNo**Override automatic comment allocation** Leave empty for smart allocation based on post count: - 2 posts: ~500 comments/post - 10 posts: ~100 comments/post - 20 posts: ~50 comments/post Only override if you need specific comment depth.
fetch_commentsNo**Fetch comments from posts (RECOMMENDED: true)** Comments often contain the BEST insights, solutions, and real-world experiences. Set to true (default): Get post + comments Set to false: Get post content only (faster but misses insights)
what_to_extractNo**Extraction instructions for AI (used when use_llm=true)** Tell the AI what specific information to extract: - "Extract recommendations for [topic] with pros/cons" - "Summarize common issues and solutions mentioned" - "Identify consensus on [specific question]" If not provided, defaults to general insight extraction. More specific instructions = better extraction quality!

TDQS

A4.3/5.0
Behavior4/5

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

The description discloses the comment budget (1000 total), automatic allocation formula, and effects of parameters like max_comments and use_llm. It mentions cost and requirement for use_llm and recommends fetch_comments=true. However, it does not address rate limits, error handling, authentication, or how input validation works (e.g., invalid URLs). Since no annotations exist, the description carries the burden, but it is still largely transparent.

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

Conciseness3/5

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

The description is structured with bold headings, bullet points, and an example section, making it scannable. However, it is quite long (multiple paragraphs, pro tips, trade-off tables). While every sentence adds value, the overall length could be trimmed for conciseness without losing essential information.

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 5 parameters and no output schema, the description thoroughly explains input behavior and workflow. However, it does not describe the output structure or return format (e.g., what fields the response contains). An agent would need to infer or assume the output shape. This is a notable gap, especially with no output schema provided.

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 description coverage is 100%. The description adds value beyond the schema by explaining the automatic calculation for max_comments, cost and environment variable for use_llm, and extraction instructions for what_to_extract. It also provides examples for what_to_extract and pro tips for fetch_comments. This enriches the agent's understanding without redundancy.

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?

The description clearly states it fetches Reddit posts with smart comment allocation, specifying the resource (Reddit posts) and action (fetch). It distinguishes itself from sibling tools like search_reddit, which finds posts, and deep_research, web_search, scrape_links, which serve different purposes.

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 provides explicit guidance on when to use different post counts (2-5 for deep dive, 10-15 balanced, 20-30 recommended, 40-50 controversial), trade-offs, and workflow linking to search_reddit. It also gives a concrete example of a bad vs good URL array, and pro tips for subreddit mixing.

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

search_redditA

🔥 REDDIT SEARCH - MINIMUM 10 QUERIES, RECOMMENDED 20+

This tool is designed for consensus analysis through MULTIPLE diverse queries. Using 1-3 queries = wasting the tool's power. You MUST use 10+ queries minimum.

Budget: 10 results per query, all run in parallel.

  • 10 queries = 100 results

  • 20 queries = 200 results (RECOMMENDED)

  • 50 queries = 500 results (comprehensive)

10-Category Query Formula - Each query targets a DIFFERENT angle. NO OVERLAP!

  1. Direct topic: "[topic] [platform]" Example: "YouTube Music Mac app"

  2. Recommendations: "best/recommended [topic]" Example: "best YouTube Music client Mac"

  3. Specific tools: Project names, GitHub repos Example: "YTMDesktop", "th-ch youtube-music"

  4. Comparisons: "[A] vs [B]" Example: "YouTube Music vs Spotify Mac desktop"

  5. Alternatives: "[topic] alternative/replacement" Example: "YouTube Music Mac alternative"

  6. Subreddits: "r/[subreddit] [topic]" - different communities have different perspectives Example: "r/macapps YouTube Music", "r/opensource YouTube Music"

  7. Problems/Issues: "[topic] issues/crashes/problems" Example: "YouTube Music Mac crashes", "YTM desktop performance problems"

  8. Year-specific: Add "2024" or "2025" for recent discussions Example: "best YouTube Music Mac 2024"

  9. Features: "[topic] [specific feature]" Example: "YouTube Music offline Mac", "YTM lyrics desktop"

  10. Developer/GitHub: "[topic] GitHub/open source/electron" Example: "youtube-music electron GitHub", "YTM desktop open source"

Search Operators:

  • intitle: - Search in post titles only

  • "exact phrase" - Match exact phrase

  • OR - Match either term

  • -exclude - Exclude term

  • All queries auto-add site:reddit.com

Example showing all 10 categories: ❌ BAD: {"queries": ["best YouTube Music app"]} → 1 vague query, misses 90% of consensus ✅ GOOD: {"queries": ["YouTube Music Mac app", "best YTM client Mac", "YTMDesktop Mac", "YouTube Music vs Spotify Mac", "YouTube Music Mac alternative", "r/macapps YouTube Music", "YTM Mac crashes", "YouTube Music Mac 2024", "YTM offline Mac", "youtube-music GitHub", ...expand to 20 queries]} → comprehensive multi-angle coverage

Pro Tips:

  1. Use ALL 10 categories - Each reveals different community perspectives

  2. Target specific subreddits - Different communities have different expertise

  3. Include year numbers - "2024", "2025" filters for recent discussions

  4. Add comparison keywords - "vs", "versus" find decision threads

  5. Include problem keywords - "issue", "bug", "crash" find real experiences

  6. Vary phrasing - "best", "top", "recommended" capture different discussions

  7. Use technical terms - "electron", "GitHub", "API" find developer perspectives

  8. NO DUPLICATES - Each query must target a unique angle

Workflow: search_reddit → sequentialthinking (evaluate results) → get_reddit_post OR search again → sequentialthinking → synthesize

REMEMBER: More queries = better consensus detection = higher quality results!

ParametersJSON Schema
NameRequiredDescriptionDefault
queriesYes**10-50 diverse queries** (Minimum 10 required, 20-30 recommended) Each query MUST target a different angle using the 10-category formula. No duplicates, no overlap - maximize diversity for comprehensive consensus. **Quick Checklist:** ✓ Direct topic queries ✓ Recommendation queries ("best", "recommended") ✓ Specific tool/project names ✓ Comparisons ("vs", "versus") ✓ Subreddit targeting ("r/...") ✓ Year-specific (2024, 2025) ✓ Problem keywords (issue, bug, crash) ✓ Feature keywords ✓ Developer angle (GitHub, open source)
date_afterNoFilter results after date (YYYY-MM-DD). Example: '2024-01-01'

TDQS

A3.9/5.0
Behavior3/5

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

With no annotations, the description carries full burden. It discloses that queries run in parallel, results are capped at 10 per query, and all queries auto-add 'site:reddit.com'. It also describes the search operators and pro tips. However, it does not mention rate limits, authentication requirements, or response structure. Given the absence of annotations, it provides moderate transparency but could be more explicit about non-mutating behavior.

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

Conciseness2/5

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

The description is excessively long (over 500 words) with repeated emphasis on '10+ queries' and multiple examples. While well-structured with headings and bullet points, it could be significantly trimmed without losing essential guidance. The pro tips and workflow section, though helpful, contribute to verbosity. A more concise version would retain all critical information.

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 complexity (multi-query, parallel execution) and the absence of an output schema, the description should explain return format, pagination, and how to access full post content. It mentions 'results' and budget (10 per query) but omits details on result structure, potential errors, or empty results. The workflow hints at get_reddit_post for details, partially compensating. Overall, it is adequate but not fully complete.

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

Parameters5/5

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

Schema coverage is 100% with a detailed description for 'queries' including min/max items and a checklist. The tool description adds substantial value by introducing the 10-category query formula, examples, and the concept of consensus analysis. This goes far beyond the schema's static description. The second parameter 'date_after' is simple but adequately described.

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?

The description clearly identifies the tool as a Reddit search for consensus analysis, with a specific verb ('search') and resource ('Reddit'). It distinguishes from siblings like 'web_search' (general web) and 'get_reddit_post' (single post retrieval) by emphasizing multi-query diversity and consensus detection. The title and description together make the purpose unmistakable.

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

Usage Guidelines4/5

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

The description provides explicit usage context: it is intended for multi-angle consensus analysis with a minimum of 10 queries. It includes a workflow (search_reddit → sequentialthinking → get_reddit_post or search again) and contrasts with alternatives (e.g., deep_research). However, it does not explicitly state when not to use the tool (e.g., for a single simple query), but the strong emphasis on 10+ queries implies it.

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

A4.2/5.0
Disambiguation5/5

Each tool has a distinctly described purpose: deep_research for AI-powered parallel research, search_reddit for Reddit search, get_reddit_post for fetching posts, scrape_links for web scraping, and web_search for Google searches. The overlapping domains (e.g., both web_search and deep_research involve searching) are well-differentiated by their approaches and use cases.

Naming Consistency3/5

Tool names use snake_case but follow inconsistent patterns: deep_research (adjective_noun) vs. get_reddit_post, scrape_links, search_reddit (verb_noun) vs. web_search (noun_verb). The mix of verb positions and adjective usage makes naming less predictable.

Tool Count5/5

Five tools cover the major research modalities (AI research, web search, Reddit search and fetch, web scraping) without redundancy. The count is well-scoped for a research-focused server, neither too few nor too many.

Completeness4/5

The tool set provides a solid foundation for research: searching, scraping, and deep investigation. Minor gaps exist, such as a dedicated tool for synthesizing or storing results, but agents can use sequential thinking to compensate. Core workflows are covered.

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

Appeared in Searches

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/yigitkonur/research-powerpack-mcp'

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