get_web_search_summaries

Obtain web search summaries to quickly identify available sources and understand topic scope before deeper research, providing titles, URLs, and brief descriptions.

Instructions

Get lightweight web search results with only result summaries.

Use this when you need a quick overview of available sources without full content. This gets search result titles, URLs, and descriptions for quick research or when you only need an overview of available information.

Use this when you want to quickly understand what information is available on a topic before diving deeper with full content extraction.

Args: query: Search query string (1-200 characters) limit: Number of search result summaries to return (1-10, default 5) top_n: Alternative name for limit (for compatibility) recency_days: Days to look back for recent content (time filtering) source: Content type filter ("news", "images", "videos", etc.) language: Language filter (e.g., "en", "es", "fr", "de") country: Geographic filter (e.g., "US", "GB", "FR", "DE")

Returns: Formatted text containing search result summaries (title, URL, description)

Parameter Usage Guidelines

query (required)

Search query string (1-200 characters)
Use specific, descriptive search terms

limit (optional, default 5)

Range: 1-10 results

Usage Examples

Basic topic exploration:

{ "query": "artificial intelligence ethics" }

Quick source discovery:

{ "query": "kubernetes security best practices", "limit": 3 }

Recent news exploration:

{ "query": "AI developments", "source": "news", "recency_days": 7, "language": "en" }

Geographic research:

{ "query": "renewable energy policies", "country": "DE", "language": "en", "limit": 8 }

Content type discovery:

{ "query": "machine learning tutorials", "source": "videos", "limit": 5 }

Complete parameter example:

{ "query": "climate change adaptation strategies", "limit": 6, "recency_days": 30, "language": "en", "country": "US" }

When to Choose This Tool

Primary Decision Criteria:

Choose this for initial research phase: Understand what sources are available
Choose this for topic exploration: Get an overview before deep diving
Choose this for source identification: Find relevant URLs for later extraction
Choose this for quick fact-checking: Verify if information sources exist
Choose this for research planning: Identify the scope of available information

Decision Matrix: When to Use Each Tool

Use `get_web_search_summaries` when:

✅ You need to explore what's available on a topic
✅ You want to identify relevant sources quickly
✅ You're doing preliminary research
✅ You need to validate if sources exist
✅ You want to see search result diversity
✅ Speed is more important than content depth

Use `full_web_search` when:

✅ You need actual content from sources
✅ You're doing detailed research or analysis
✅ You need to cite or reference specific information
✅ You want to compare information across sources
✅ Content depth is more important than speed

Use `get_single_web_page_content` when:

✅ You have specific URLs to extract
✅ You found relevant URLs from summaries
✅ You need to extract from known sources

Workflow Patterns

Two-stage research:

Use get_web_search_summaries to identify sources
Use get_single_web_page_content on promising URLs
Or use full_web_search with focused query

Topic mapping:

Use get_web_search_summaries with broad terms
Analyze result diversity and topics
Use full_web_search for detailed investigation

Source validation:

Use get_web_search_summaries to check if sources exist
Evaluate source quality and relevance
Proceed with content extraction if validated

Input Schema

TableJSON Schema

Name	Required	Description	Default
`query`	Yes
`limit`	No
`top_n`	No
`recency_days`	No
`source`	No
`language`	No
`country`	No

Implementation Reference

features/web_search/tool.py:99-154 (handler)
MCP tool handler 'get_web_search_summaries': processes input parameters, calls WebSearchService.search_summaries, formats results as formatted text response for MCP protocol.
@mcp.tool() @inject_docstring(lambda: load_instruction("instructions_summaries.md", __file__)) async def get_web_search_summaries( query: str, limit: int = 5, top_n: int = None, # Alternative name for limit (for compatibility) recency_days: int = None, # Days to look back (now supported!) source: str = None, # Source type filter (partially supported) language: str = None, # Language filter (now supported!) country: str = None # Country filter (now supported!) ) -> Dict[str, Any]: """Lightweight web search returning only summaries""" try: # Handle alternative parameter names actual_limit = top_n if top_n is not None else limit # Prepare supported parameters search_params = {} if recency_days is not None: search_params['recency_days'] = recency_days logger.info(f"Using recency_days filter: {recency_days} days") if source is not None: search_params['source'] = source logger.info(f"Using source filter: '{source}'") if language is not None: search_params['language'] = language logger.info(f"Using language filter: '{language}'") if country is not None: search_params['country'] = country logger.info(f"Using country filter: '{country}'") logger.info(f"MCP tool get_web_search_summaries: query='{query}', limit={actual_limit}") result = await web_search_service.search_summaries( query=query, limit=min(actual_limit, 10), # Cap at 10 **search_params # Pass all supported parameters to service ) # Format for MCP response response_text = f"Search summaries for '{result['query']}' with {result['total_results']} results:\n\n" for i, summary in enumerate(result['results'], 1): response_text += f"**{i}. {summary['title']}**\n" response_text += f"URL: {summary['url']}\n" response_text += f"Description: {summary['description']}\n\n---\n\n" logger.info(f"MCP tool get_web_search_summaries completed: {result['total_results']} results") return { "content": [{"type": "text", "text": response_text}] } except Exception as e: logger.error(f"MCP tool get_web_search_summaries error: {e}") raise
features/web_search/tool.py:17-24 (registration)
Registration function 'register_tool' that defines and registers the 'get_web_search_summaries' MCP tool (and others) using @mcp.tool() decorators inside it.
def register_tool(mcp: FastMCP, web_search_service: WebSearchService) -> None: """ Register web search tools with the MCP server Args: mcp: FastMCP server instance web_search_service: WebSearchService instance """
features/web_search/service.py:83-103 (helper)
Core helper method 'search_summaries' in WebSearchService: performs lightweight multi-engine web search (DDGS/Brave/DuckDuckGo), returns structured summaries used by the MCP handler.
async def search_summaries(self, query: str, limit: int = 5, **kwargs) -> Dict[str, Any]: """Lightweight search returning only summaries using multi-engine approach""" logger.info(f"Starting multi-engine search for summaries: '{query}' with parameters: {kwargs}") # Use multi-engine search instead of just Brave API results = await self._multi_engine_search(query, limit, **kwargs) # Format results as summaries (no content extraction needed) return { "query": query, "results": [ { "title": r.title, "url": r.url, "description": r.description, "timestamp": r.timestamp } for r in results ], "total_results": len(results), "status": "success" }
features/web_search/models.py:42-48 (schema)
Pydantic schema model SearchSummaryModel defining the structure of individual search summary results returned by the service.
class SearchSummaryModel(BaseModel): """Search result summary (no content)""" title: str = Field(..., description="Page title") url: str = Field(..., description="Page URL") description: str = Field(..., description="Search result description") timestamp: Optional[str] = Field(None, description="Timestamp")
features/web_search/service.py:111-132 (helper)
Supporting helper '_multi_engine_search': orchestrates fallback across multiple search engines (DDGS preferred, then Brave, DuckDuckGo) with parameter support and quality assessment.
async def _multi_engine_search(self, query: str, limit: int, **kwargs) -> List[SearchResult]: """Try multiple search engines in order of preference""" engines = [ ("DDGS", self._search_ddgs), # DDGS with Brave/DDG backends (highest priority) ("Brave", self._search_brave), # Browser-based Brave (fallback) ("DuckDuckGo", self._search_duckduckgo) # Browser-based DDG (last resort) ] for engine_name, engine_func in engines: try: logger.info(f"Trying {engine_name} search engine") results = await engine_func(query, limit, **kwargs) if results and self._assess_result_quality(results, query) >= 0.3: logger.info(f"Using results from {engine_name}: {len(results)} results") return results[:limit] except Exception as e: logger.warning(f"Search engine {engine_name} failed: {e}") continue logger.warning("All search engines failed, returning empty results") return []

MCP MixSearch