google-news-trends-mcp 0.1.0__py3-none-any.whl

google_news_trends_mcp/__main__.py

@@ -0,0 +1,5 @@
+from google_news_trends_mcp.server import main
+
+
+if __name__ == "__main__":
+    main()

google_news_trends_mcp/cli.py

@@ -0,0 +1,149 @@
+import click
+import asyncio
+from google_news_trends_mcp.news import (
+    get_news_by_keyword,
+    get_news_by_location,
+    get_news_by_topic,
+    get_trending_terms,
+    get_top_news,
+    save_article_to_json,
+)
+
+
+@click.group()
+def cli():
+    pass
+
+
+@cli.command(help=get_news_by_keyword.__doc__)
+@click.argument("keyword")
+@click.option(
+    "--period", type=int, default=7, help="Period in days to search for articles."
+)
+@click.option(
+    "--max-results",
+    "max_results",
+    type=int,
+    default=10,
+    help="Maximum number of results to return.",
+)
+@click.option(
+    "--no-nlp", is_flag=True, default=False, help="Disable NLP processing for articles."
+)
+def keyword(keyword, period, max_results, no_nlp):
+    articles = asyncio.run(
+        get_news_by_keyword(
+            keyword, period=period, max_results=max_results, nlp=not no_nlp
+        )
+    )
+    # asyncio.run(articles)  # Ensure the articles are fetched asynchronously
+    print_articles(articles)
+
+
+@cli.command(help=get_news_by_location.__doc__)
+@click.argument("location")
+@click.option(
+    "--period", type=int, default=7, help="Period in days to search for articles."
+)
+@click.option(
+    "--max-results",
+    "max_results",
+    type=int,
+    default=10,
+    help="Maximum number of results to return.",
+)
+@click.option(
+    "--no-nlp", is_flag=True, default=False, help="Disable NLP processing for articles."
+)
+def location(location, period, max_results, no_nlp):
+    articles = asyncio.run(
+        get_news_by_location(
+            location, period=period, max_results=max_results, nlp=not no_nlp
+        )
+    )
+    print_articles(articles)
+
+
+@cli.command(help=get_news_by_topic.__doc__)
+@click.argument("topic")
+@click.option(
+    "--period", type=int, default=7, help="Period in days to search for articles."
+)
+@click.option(
+    "--max-results",
+    "max_results",
+    type=int,
+    default=10,
+    help="Maximum number of results to return.",
+)
+@click.option(
+    "--no-nlp", is_flag=True, default=False, help="Disable NLP processing for articles."
+)
+def topic(topic, period, max_results, no_nlp):
+    articles = asyncio.run(
+        get_news_by_topic(topic, period=period, max_results=max_results, nlp=not no_nlp)
+    )
+    print_articles(articles)
+
+
+@cli.command(help=get_trending_terms.__doc__)
+@click.option(
+    "--geo", type=str, default="US", help="Country code, e.g. 'US', 'GB', 'IN', etc."
+)
+@click.option(
+    "--full-data", is_flag=True, default=False, help="Return full data for each trend."
+)
+@click.option(
+    "--max-results",
+    "max_results",
+    type=int,
+    default=100,
+    help="Maximum number of results to return.",
+)
+def trending(geo, full_data, max_results):
+    trending_terms = asyncio.run(
+        get_trending_terms(geo=geo, full_data=full_data, max_results=max_results)
+    )
+    if trending_terms:
+        print("Trending terms:")
+        for term in trending_terms:
+            print(f"- {term}")
+    else:
+        print("No trending terms found.")
+
+
+@cli.command(help=get_top_news.__doc__)
+@click.option(
+    "--period", type=int, default=3, help="Period in days to search for top articles."
+)
+@click.option(
+    "--max-results",
+    "max_results",
+    type=int,
+    default=10,
+    help="Maximum number of results to return.",
+)
+@click.option(
+    "--no-nlp", is_flag=True, default=False, help="Disable NLP processing for articles."
+)
+def top(period, max_results, no_nlp):
+    articles = asyncio.run(
+        get_top_news(max_results=max_results, period=period, nlp=not no_nlp)
+    )
+    print_articles(articles)
+    print(f"Found {len(articles)} top articles.")
+
+
+def print_articles(articles):
+    for article in articles:
+        print(f"Title: {article.title}")
+        print(f"URL: {article.original_url}")
+        print(f"Authors: {article.authors}")
+        print(f"Publish Date: {article.publish_date}")
+        print(f"Top Image: {article.top_image}")
+        print(f"Summary: {article.summary}\n")
+        save_article_to_json(article)
+
+
+if __name__ == "__main__":
+    cli()

google_news_trends_mcp/news.py

@@ -0,0 +1,326 @@
+"""
+# news.py
+This module provides functions to find and download news articles using Google News.
+It allows searching for articles by keyword, location, or topic, and can also retrieve google trending terms.
+It uses the `gnews` library to search for news articles and trendspy to get Google Trends data.
+It will fallback to using Playwright for websites that are difficult to scrape with newspaper4k or cloudscraper.
+"""
+
+import re
+import json
+import time
+import asyncio
+from gnews import GNews
+import newspaper  # newspaper4k
+from googlenewsdecoder import gnewsdecoder
+import cloudscraper
+from playwright.async_api import async_playwright, Browser
+from trendspy import Trends, TrendKeyword
+import click
+from typing import Optional
+import atexit
+from contextlib import asynccontextmanager
+
+tr = Trends()
+
+scraper = cloudscraper.create_scraper(
+    # Challenge handling
+    interpreter="js2py",  # Best compatibility for v3 challenges
+    delay=5,  # Extra time for complex challenges
+    # Stealth mode
+    # enable_stealth=True,
+    # stealth_options={
+    #     'min_delay': 2.0,
+    #     'max_delay': 6.0,
+    #     'human_like_delays': True,
+    #     'randomize_headers': True,
+    #     'browser_quirks': True
+    # },
+    # Browser emulation
+    browser="chrome",
+    # Debug mode
+    debug=False,
+)
+
+google_news = GNews(
+    language="en",
+    exclude_websites=["mensjournal.com"],
+)
+
+playwright = None
+browser: Browser = None
+
+
+async def startup_browser():
+    global playwright, browser
+    playwright = await async_playwright().start()
+    browser = await playwright.chromium.launch(headless=True)
+
+
+@atexit.register
+def shutdown_browser():
+    if browser:
+        asyncio.run(browser.close())
+    if playwright:
+        asyncio.run(playwright.stop())
+
+
+async def get_browser() -> Browser:
+    global browser
+    if browser is None:
+        await startup_browser()
+    return browser
+
+
+@asynccontextmanager
+async def browser_context():
+    context = await (await get_browser()).new_context()
+    try:
+        yield context
+    finally:
+        print("Closing browser context...")
+        await context.close()
+
+
+async def download_article_with_playwright(url) -> newspaper.Article | None:
+    """
+    Download an article using Playwright to handle complex websites (async).
+    """
+    try:
+        async with browser_context() as context:
+            # context = await new_context()
+            page = await context.new_page()
+            await page.goto(url, wait_until="domcontentloaded")
+            await asyncio.sleep(2)  # Wait for the page to load completely
+            content = await page.content()
+            # await context.close()
+            article = newspaper.article(url, input_html=content, language="en")
+            return article
+    except Exception as e:
+        print(f"Error downloading article with Playwright from {url}\n {e.args}")
+        return None
+
+
+async def download_article(url: str, nlp: bool = True) -> newspaper.Article | None:
+    """
+    Download an article from a given URL using newspaper4k and cloudscraper (async).
+    """
+    article = None
+    if url.startswith("https://news.google.com/rss/"):
+        try:
+            decoded_url = gnewsdecoder(url)
+            if decoded_url.get("status"):
+                url = decoded_url["decoded_url"]
+            else:
+                print("Failed to decode Google News RSS link:")
+                return None
+        except Exception as err:
+            print(f"Error while decoding url {url}\n {err.args}")
+    try:
+        article = newspaper.article(url)
+    except Exception as e:
+        print(f"Error downloading article with newspaper from {url}\n {e.args}")
+        try:
+            # Retry with cloudscraper
+            response = scraper.get(url)
+            if response.status_code < 400:
+                article = newspaper.article(url, input_html=response.text)
+            else:
+                print(
+                    f"Failed to download article with cloudscraper from {url}, status code: {response.status_code}"
+                )
+        except Exception as e:
+            print(f"Error downloading article with cloudscraper from {url}\n {e.args}")
+
+    try:
+        if article is None:
+            # If newspaper failed, try downloading with Playwright
+            print(f"Retrying with Playwright for {url}")
+            article = await download_article_with_playwright(url)
+        article.parse()
+        if nlp:
+            article.nlp()
+        if article.publish_date:
+            article.publish_date = article.publish_date.isoformat()
+    except Exception as e:
+        print(f"Error parsing article from {url}\n {e.args}")
+        return None
+    return article
+
+
+async def process_gnews_articles(
+    gnews_articles: list[dict], nlp: bool = True
+) -> list["newspaper.Article"]:
+    """
+    Process a list of Google News articles and download them (async).
+    """
+    articles = []
+    for gnews_article in gnews_articles:
+        article = await download_article(gnews_article["url"], nlp=nlp)
+        if article is None or not article.text:
+            print(f"Failed to download article from {gnews_article['url']}:\n{article}")
+            continue
+        articles.append(article)
+    return articles
+
+
+async def get_news_by_keyword(
+    keyword: str, period=7, max_results: int = 10, nlp: bool = True
+) -> list[newspaper.Article]:
+    """
+    Find articles by keyword using Google News.
+    keyword: is the search term to find articles.
+    period: is the number of days to look back for articles.
+    max_results: is the maximum number of results to return.
+    nlp: If True, will perform NLP on the articles to extract keywords and summary.
+    Returns:
+        list[newspaper.Article]: A list of newspaper.Article objects containing the articles.
+    """
+    google_news.period = f"{period}d"
+    google_news.max_results = max_results
+    gnews_articles = google_news.get_news(keyword)
+    if not gnews_articles:
+        print(f"No articles found for keyword '{keyword}' in the last {period} days.")
+        return []
+    return await process_gnews_articles(gnews_articles, nlp=nlp)
+
+
+async def get_top_news(
+    period: int = 3, max_results: int = 10, nlp: bool = True
+) -> list["newspaper.Article"]:
+    """
+    Get top news stories from Google News.
+    period: is the number of days to look back for top articles.
+    max_results: is the maximum number of results to return.
+    nlp: If True, will perform NLP on the articles to extract keywords and summary.
+    Returns:
+        list[newspaper.Article]: A list of newspaper.Article objects containing the top news articles.
+    """
+    google_news.period = f"{period}d"
+    google_news.max_results = max_results
+    gnews_articles = google_news.get_top_news()
+    if not gnews_articles:
+        print("No top news articles found.")
+        return []
+    return await process_gnews_articles(gnews_articles, nlp=nlp)
+
+
+async def get_news_by_location(
+    location: str, period=7, max_results: int = 10, nlp: bool = True
+) -> list[newspaper.Article]:
+    """Find articles by location using Google News.
+    location: is the name of city/state/country
+    period: is the number of days to look back for articles.
+    max_results: is the maximum number of results to return.
+    nlp: If True, will perform NLP on the articles to extract keywords and summary.
+    Returns:
+        list[newspaper.Article]: A list of newspaper.Article objects containing the articles for the specified location
+    """
+    google_news.period = f"{period}d"
+    google_news.max_results = max_results
+    gnews_articles = google_news.get_news_by_location(location)
+    if not gnews_articles:
+        print(f"No articles found for location '{location}' in the last {period} days.")
+        return []
+    return await process_gnews_articles(gnews_articles, nlp=nlp)
+
+
+async def get_news_by_topic(
+    topic: str, period=7, max_results: int = 10, nlp: bool = True
+) -> list[newspaper.Article]:
+    """Find articles by topic using Google News.
+    topic is one of
+    WORLD, NATION, BUSINESS, TECHNOLOGY, ENTERTAINMENT, SPORTS, SCIENCE, HEALTH,
+    POLITICS, CELEBRITIES, TV, MUSIC, MOVIES, THEATER, SOCCER, CYCLING, MOTOR SPORTS,
+    TENNIS, COMBAT SPORTS, BASKETBALL, BASEBALL, FOOTBALL, SPORTS BETTING, WATER SPORTS,
+    HOCKEY, GOLF, CRICKET, RUGBY, ECONOMY, PERSONAL FINANCE, FINANCE, DIGITAL CURRENCIES,
+    MOBILE, ENERGY, GAMING, INTERNET SECURITY, GADGETS, VIRTUAL REALITY, ROBOTICS, NUTRITION,
+    PUBLIC HEALTH, MENTAL HEALTH, MEDICINE, SPACE, WILDLIFE, ENVIRONMENT, NEUROSCIENCE, PHYSICS,
+    GEOLOGY, PALEONTOLOGY, SOCIAL SCIENCES, EDUCATION, JOBS, ONLINE EDUCATION, HIGHER EDUCATION,
+    VEHICLES, ARTS-DESIGN, BEAUTY, FOOD, TRAVEL, SHOPPING, HOME, OUTDOORS, FASHION.
+    period: is the number of days to look back for articles.
+    max_results: is the maximum number of results to return.
+    nlp: If True, will perform NLP on the articles to extract keywords and summary.
+    Returns:
+        list[newspaper.Article]: A list of newspaper.Article objects containing the articles for the specified topic
+    """
+    google_news.period = f"{period}d"
+    google_news.max_results = max_results
+    gnews_articles = google_news.get_news_by_topic(topic)
+    if not gnews_articles:
+        print(f"No articles found for topic '{topic}' in the last {period} days.")
+        return []
+    return await process_gnews_articles(gnews_articles, nlp=nlp)
+
+
+async def get_trending_terms(
+    geo: str = "US", full_data: bool = False, max_results: int = 100
+) -> list[tuple[str, int]] | list[TrendKeyword]:
+    """
+    Returns google trends for a specific geo location.
+    Default is US.
+    geo: is the country code, e.g. 'US', 'GB', 'IN', etc.
+    full_data: if True, returns full data for each trend, otherwise returns only the trend and volume.
+    max_results: is the maximum number of results to return, default is 100.
+    Returns:
+        list[tuple[str, int]]: A list of tuples containing the trend keyword and its volume.
+        If full_data is True, each tuple will also contain additional data such as related queries and trend type.
+    """
+    try:
+        trends = list(tr.trending_now(geo=geo))
+        trends = list(sorted(trends, key=lambda tt: tt.volume, reverse=True))[
+            :max_results
+        ]
+        if not full_data:
+            return [(trend.keyword, trend.volume) for trend in trends]
+        return trends
+    except Exception as e:
+        print(f"Error fetching trending terms: {e}")
+        return []
+
+
+def save_article_to_json(article: newspaper.Article, filename: str = "") -> None:
+    def sanitize_filename(title: str) -> str:
+        """
+        # save Article to json file
+        # filename is based on the article title
+        # if the title is too long, it will be truncated to 50 characters
+        # and replaced with underscores if it contains any special characters
+        """
+        # Replace special characters and spaces with underscores, then truncate to 50 characters
+        sanitized_title = re.sub(r'[\\/*?:"<>|\s]', "_", title)[:50]
+        return sanitized_title + ".json"
+
+    """
+    Save an article to a JSON file.
+    """
+    article_data = {
+        "title": article.title,
+        "authors": article.authors,
+        "publish_date": str(article.publish_date) if article.publish_date else None,
+        "top_image": article.top_image,
+        "images": article.images,
+        "text": article.text,
+        "url": article.original_url,
+        "summary": article.summary,
+        "keywords": article.keywords,
+        "keyword_scores": article.keyword_scores,
+        "tags": article.tags,
+        "meta_keywords": article.meta_keywords,
+        "meta_description": article.meta_description,
+        "canonical_link": article.canonical_link,
+        "meta_data": article.meta_data,
+        "meta_lang": article.meta_lang,
+        "source_url": article.source_url,
+    }
+
+    if not filename:
+        # Use the article title to create a filename
+        filename = sanitize_filename(article.title)
+    else:
+        # Ensure the filename ends with .json
+        if not filename.endswith(".json"):
+            filename += ".json"
+    with open(filename, "w") as f:
+        json.dump(article_data, f, indent=4)
+    print(f"Article saved to {filename}")

google_news_trends_mcp/server.py

@@ -0,0 +1,260 @@
+from fastmcp import FastMCP
+from fastmcp.exceptions import ToolError
+from fastmcp.server.dependencies import get_context
+from pydantic import BaseModel, Field
+from typing import Optional
+from google_news_trends_mcp import news
+from typing import Annotated
+from fastmcp.server.middleware.timing import TimingMiddleware
+from fastmcp.server.middleware.logging import LoggingMiddleware
+from fastmcp.server.middleware.rate_limiting import RateLimitingMiddleware
+from fastmcp.server.middleware.error_handling import ErrorHandlingMiddleware
+
+
+class ArticleOut(BaseModel):
+    read_more_link: Annotated[
+        Optional[str], Field(description="Link to read more about the article.")
+    ] = None
+    language: Annotated[
+        Optional[str], Field(description="Language code of the article.")
+    ] = None
+    meta_img: Annotated[Optional[str], Field(description="Meta image URL.")] = None
+    movies: Annotated[
+        Optional[list[str]], Field(description="List of movie URLs or IDs.")
+    ] = None
+    meta_favicon: Annotated[
+        Optional[str], Field(description="Favicon URL from meta data.")
+    ] = None
+    meta_site_name: Annotated[
+        Optional[str], Field(description="Site name from meta data.")
+    ] = None
+    title: Annotated[str, Field(description="Title of the article.")]
+    authors: Annotated[Optional[list[str]], Field(description="list of authors.")] = (
+        None
+    )
+    publish_date: Annotated[
+        Optional[str], Field(description="Publish date in ISO format.")
+    ] = None
+    top_image: Annotated[Optional[str], Field(description="URL of the top image.")] = (
+        None
+    )
+    images: Annotated[Optional[list[str]], Field(description="list of image URLs.")] = (
+        None
+    )
+    text: Annotated[str, Field(description="Full text of the article.")]
+    url: Annotated[str, Field(description="Original article URL.")]
+    summary: Annotated[Optional[str], Field(description="Summary of the article.")] = (
+        None
+    )
+    keywords: Annotated[
+        Optional[list[str]], Field(description="Extracted keywords.")
+    ] = None
+    tags: Annotated[Optional[list[str]], Field(description="Tags for the article.")] = (
+        None
+    )
+    meta_keywords: Annotated[
+        Optional[list[str]], Field(description="Meta keywords from the article.")
+    ] = None
+    meta_description: Annotated[
+        Optional[str], Field(description="Meta description from the article.")
+    ] = None
+    canonical_link: Annotated[
+        Optional[str], Field(description="Canonical link for the article.")
+    ] = None
+    meta_data: Annotated[
+        Optional[dict[str, str | int]], Field(description="Meta data dictionary.")
+    ] = None
+    meta_lang: Annotated[
+        Optional[str], Field(description="Language of the article.")
+    ] = None
+    source_url: Annotated[
+        Optional[str], Field(description="Source URL if different from original.")
+    ] = None
+
+
+class TrendingTermArticleOut(BaseModel):
+    title: Annotated[str, Field(description="Article title.")] = ""
+    url: Annotated[str, Field(description="Article URL.")] = ""
+    source: Annotated[Optional[str], Field(description="News source name.")] = None
+    picture: Annotated[Optional[str], Field(description="URL to article image.")] = None
+    time: Annotated[
+        Optional[str | int], Field(description="Publication time or timestamp.")
+    ] = None
+    snippet: Annotated[Optional[str], Field(description="Article preview text.")] = None
+
+
+class TrendingTermOut(BaseModel):
+    keyword: Annotated[str, Field(description="Trending keyword.")]
+    volume: Annotated[Optional[int], Field(description="Search volume.")] = None
+    geo: Annotated[Optional[str], Field(description="Geographic location code.")] = None
+    started_timestamp: Annotated[
+        Optional[list],
+        Field(
+            description="When the trend started (year, month, day, hour, minute, second)."
+        ),
+    ] = None
+    ended_timestamp: Annotated[
+        Optional[tuple[int, int]],
+        Field(
+            description="When the trend ended (year, month, day, hour, minute, second)."
+        ),
+    ] = None
+    volume_growth_pct: Annotated[
+        Optional[float], Field(description="Percentage growth in search volume.")
+    ] = None
+    trend_keywords: Annotated[
+        Optional[list[str]], Field(description="Related keywords.")
+    ] = None
+    topics: Annotated[
+        Optional[list[str | int]], Field(description="Related topics.")
+    ] = None
+    news: Annotated[
+        Optional[list[TrendingTermArticleOut]],
+        Field(description="Related news articles."),
+    ] = None
+    news_tokens: Annotated[
+        Optional[list], Field(description="Associated news tokens.")
+    ] = None
+    normalized_keyword: Annotated[
+        Optional[str], Field(description="Normalized form of the keyword.")
+    ] = None
+
+
+mcp = FastMCP(
+    name="google-news-trends",
+    instructions="This server provides tools to search, analyze, and summarize Google News articles and Google Trends",
+    on_duplicate_tools="replace",
+)
+
+mcp.add_middleware(ErrorHandlingMiddleware())  # Handle errors first
+mcp.add_middleware(RateLimitingMiddleware(max_requests_per_second=50))
+mcp.add_middleware(TimingMiddleware())  # Time actual execution
+mcp.add_middleware(LoggingMiddleware())  # Log everything
+
+
+@mcp.tool(
+    description=news.get_news_by_keyword.__doc__,
+    tags={"news", "articles", "keyword"},
+)
+async def get_news_by_keyword(
+    keyword: Annotated[str, Field(description="Search term to find articles.")],
+    period: Annotated[
+        int, Field(description="Number of days to look back for articles.", ge=1)
+    ] = 7,
+    max_results: Annotated[
+        int, Field(description="Maximum number of results to return.", ge=1)
+    ] = 10,
+    nlp: Annotated[
+        bool, Field(description="Whether to perform NLP on the articles.")
+    ] = True,
+) -> list[ArticleOut]:
+    articles = await news.get_news_by_keyword(
+        keyword=keyword,
+        period=period,
+        max_results=max_results,
+        nlp=nlp,
+    )
+    return [ArticleOut(**a.to_json(False)) for a in articles]
+
+
+@mcp.tool(
+    description=news.get_news_by_location.__doc__,
+    tags={"news", "articles", "location"},
+)
+async def get_news_by_location(
+    location: Annotated[str, Field(description="Name of city/state/country.")],
+    period: Annotated[
+        int, Field(description="Number of days to look back for articles.", ge=1)
+    ] = 7,
+    max_results: Annotated[
+        int, Field(description="Maximum number of results to return.", ge=1)
+    ] = 10,
+    nlp: Annotated[
+        bool, Field(description="Whether to perform NLP on the articles.")
+    ] = True,
+) -> list[ArticleOut]:
+    articles = await news.get_news_by_location(
+        location=location,
+        period=period,
+        max_results=max_results,
+        nlp=nlp,
+    )
+    return [ArticleOut(**a.to_json(False)) for a in articles]
+
+
+@mcp.tool(
+    description=news.get_news_by_topic.__doc__, tags={"news", "articles", "topic"}
+)
+async def get_news_by_topic(
+    topic: Annotated[str, Field(description="Topic to search for articles.")],
+    period: Annotated[
+        int, Field(description="Number of days to look back for articles.", ge=1)
+    ] = 7,
+    max_results: Annotated[
+        int, Field(description="Maximum number of results to return.", ge=1)
+    ] = 10,
+    nlp: Annotated[
+        bool, Field(description="Whether to perform NLP on the articles.")
+    ] = True,
+) -> list[ArticleOut]:
+    articles = await news.get_news_by_topic(
+        topic=topic,
+        period=period,
+        max_results=max_results,
+        nlp=nlp,
+    )
+    return [ArticleOut(**a.to_json(False)) for a in articles]
+
+
+@mcp.tool(description=news.get_top_news.__doc__, tags={"news", "articles", "top"})
+async def get_top_news(
+    period: Annotated[
+        int, Field(description="Number of days to look back for top articles.", ge=1)
+    ] = 3,
+    max_results: Annotated[
+        int, Field(description="Maximum number of results to return.", ge=1)
+    ] = 10,
+    nlp: Annotated[
+        bool, Field(description="Whether to perform NLP on the articles.")
+    ] = True,
+) -> list[ArticleOut]:
+    articles = await news.get_top_news(
+        period=period,
+        max_results=max_results,
+        nlp=nlp,
+    )
+    ctx = get_context()
+    await ctx.debug(f"Top Articles:\n{articles[0].to_json(False)}")
+    return [ArticleOut(**a.to_json(False)) for a in articles]
+
+
+@mcp.tool(
+    description=news.get_trending_terms.__doc__, tags={"trends", "google", "trending"}
+)
+async def get_trending_terms(
+    geo: Annotated[
+        str, Field(description="Country code, e.g. 'US', 'GB', 'IN', etc.")
+    ] = "US",
+    full_data: Annotated[
+        bool,
+        Field(
+            description="Return full data for each trend. Should be False for most use cases."
+        ),
+    ] = False,
+    max_results: Annotated[
+        int, Field(description="Maximum number of results to return.", ge=1)
+    ] = 100,
+) -> list[TrendingTermOut]:
+    trends = await news.get_trending_terms(
+        geo=geo, full_data=full_data, max_results=max_results
+    )
+    ctx = get_context()
+    await ctx.debug(f"Found {(trends)} trending terms")
+    if not full_data:
+        # return [TrendingTermOut(keyword=tt[0], volume=tt[1]) for tt in trends]
+        return [TrendingTermOut(keyword=tt[0], volume=tt[1]) for tt in trends]
+    return [TrendingTermOut(**tt.__dict__) for tt in trends]
+
+
+def main():
+    mcp.run()

google_news_trends_mcp-0.1.0.dist-info/METADATA

@@ -0,0 +1,182 @@
+Metadata-Version: 2.4
+Name: google-news-trends-mcp
+Version: 0.1.0
+Summary: Add your description here
+Author-email: Jesse Manek <jesse.manek@gmail.com>
+License: MIT
+Requires-Python: >=3.10.18
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: asyncio>=3.4.3
+Requires-Dist: click>=8.2.1
+Requires-Dist: cloudscraper>=1.2.71
+Requires-Dist: fastmcp>=2.9.2
+Requires-Dist: gnews>=0.4.1
+Requires-Dist: googlenewsdecoder>=0.1.7
+Requires-Dist: lxml[html-clean]>=6.0.0
+Requires-Dist: newspaper4k>=0.9.3.1
+Requires-Dist: nltk>=3.9.1
+Requires-Dist: playwright>=1.53.0
+Requires-Dist: pydantic>=2.11.7
+Requires-Dist: pytest>=8.4.1
+Requires-Dist: pytest-asyncio>=1.0.0
+Requires-Dist: trendspy>=0.1.6
+Dynamic: license-file
+
+# Google News Trends MCP
+
+An MCP server to access Google News and Google Trends.  Does not rely on any paid APIs.  
+The returned data currently uses a lot of tokens, so it is recommended to always use limits when making requests.  
+
+## Features
+
+- Search Google News articles based on keyword, location, topic
+- Get top news stories from Google News
+- Google Trends keywords base on location
+- Optional NLP processing to summarize articles and extract keywords
+
+## Installation
+
+### Using uv/uvx (recommended)
+
+When using [`uv`](https://docs.astral.sh/uv/) no specific installation is needed. We will
+use [`uvx`](https://docs.astral.sh/uv/guides/tools/) to directly run *google-news-trends-mcp*.
+
+### Using PIP
+
+```bash
+pip install google-news-trends-mcp
+```
+After installation, you can run it as a script using:
+
+```bash
+python -m google-news-trends-mcp
+```
+
+## Configuration
+
+### Configure for Claude.app
+
+Add to your Claude settings:
+
+<details>
+<summary>Using uvx</summary>
+
+```json
+{
+  "mcpServers": {
+    "google-news-trends": {
+      "command": "uvx",
+      "args": ["google-news-trends-mcp"]
+    }
+  }
+}
+```
+</details>
+
+<details>
+<summary>Using pip installation</summary>
+
+```json
+{
+  "mcpServers": {
+    "google-news-trends": {
+      "command": "python",
+      "args": ["-m", "google-news-trends-mcp"]
+    }
+  }
+}
+```
+</details>
+
+### Configure for VS Code
+
+<details>
+<summary>Using uvx</summary>
+
+```json
+{
+  "mcp": {
+    "servers": {
+      "google-news-trends": {
+        "command": "uvx",
+        "args": ["google-news-trends-mcp"]
+      }
+    }
+  }
+}
+```
+</details>
+
+<details>
+<summary>Using pip installation</summary>
+
+```json
+{
+  "mcp": {
+    "servers": {
+      "google-news-trends": {
+        "command": "python",
+        "args": ["-m", "google-news-trends-mcp"]
+      }
+    }
+  }
+}
+```
+</details>
+
+
+## Tools
+
+The following MCP tools are available:
+
+| Tool Name                | Description                                                        |
+|--------------------------|--------------------------------------------------------------------|
+| **get_news_by_keyword**  | Search for news using specific keywords.                           |
+| **get_news_by_location** | Retrieve news relevant to a particular location.                   |
+| **get_news_by_topic**    | Get news based on a chosen topic.                                  |
+| **get_top_news**         | Fetch the top news stories from Google News.                       |
+| **get_trending_keywords**| Return trending keywords from Google Trends for a specified location.|
+
+All of the news related tools have an option to summarize the text of the article using NLP (nltk)
+
+
+## CLI
+All tools can be accessed from the command line using `uv`
+
+```bash
+uv run google-news-trends
+Usage: google-news-trends [OPTIONS] COMMAND [ARGS]...
+
+  Find and download news articles using Google News.
+
+Options:
+  --help  Show this message and exit.
+
+Commands:
+  keyword   Find articles by keyword using Google News.
+  location  Find articles by location using Google News.
+  top       Get top news stories from Google News.
+  topic     Find articles by topic using Google News.
+  trending  Returns google trends for a specific geo location.
+```
+
+## Debugging
+
+```bash
+npx @modelcontextprotocol/inspector uvx google-news-trends-mcp
+```
+
+To run from within locally installed project
+
+```bash
+cd path/to/google/news/tends/mcp
+npx @modelcontextprotocol/inspector uv run google-news-trends-mcp
+```
+
+## Testing
+
+```bash
+cd path/to/google/news/tends/mcp
+python -m pytest
+```

google_news_trends_mcp-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+google_news_trends_mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+google_news_trends_mcp/__main__.py,sha256=ysiAk_xpnnW3lrLlzdIQQa71tuGBRT8WocbecBsY2Fs,87
+google_news_trends_mcp/cli.py,sha256=fi0qocr-nc3UbGKOR5GLrmfsEjhU_M6ZJ7UAyLoC8ds,4012
+google_news_trends_mcp/news.py,sha256=o3lNRx_lt1h2ojHW0pXhfQhs8n35pnvgeV6-iTi_1RA,12294
+google_news_trends_mcp/server.py,sha256=qwQ_9UKnOLybUGCmUH4sJWxKsmJHZCg7PKimFXgr58c,9468
+google_news_trends_mcp-0.1.0.dist-info/licenses/LICENSE,sha256=5dsv2ZI5EZIer0a9MktVmILVrlp5vqH_0tPIe3bRLgE,1067
+google_news_trends_mcp-0.1.0.dist-info/METADATA,sha256=B0v0vmbUG9iMON4rnp_vlUOjwCcL046xphofUtbPkrQ,4263
+google_news_trends_mcp-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+google_news_trends_mcp-0.1.0.dist-info/entry_points.txt,sha256=eVT3xd6YJQgsWAUBwhnffuwhXNF7yyt_uco6fjBy-1o,130
+google_news_trends_mcp-0.1.0.dist-info/top_level.txt,sha256=RFheDbzhNnEV_Y3iFNm7jhRhY1P1wQgfiYqVpXCTD_U,23
+google_news_trends_mcp-0.1.0.dist-info/RECORD,,

google_news_trends_mcp-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

google_news_trends_mcp-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+google-news-trends = google_news_trends_mcp.cli:cli
+google-news-trends-mcp = google_news_trends_mcp.server:main

google_news_trends_mcp-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Jesse Manek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

google_news_trends_mcp-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+google_news_trends_mcp