wikipedia_summarize_article_for_query

Instructions

Implementation Reference

• wikipedia_mcp/server.py:274-288 (handler)

  The handler function that executes the summarize_article_for_query tool logic. Registers the tool, extracts title/query/max_length params, and calls wikipedia_client.summarize_for_query().

  @register_tool("summarize_article_for_query", model_output_schema(QuerySummaryResponse))
  def summarize_article_for_query(
      title: str,
      query: str,
      max_length: Annotated[int, Field(title="Max Length")] = 250,
  ):
      """
      Get a summary of a Wikipedia article tailored to a specific query.
  
      The summary is a snippet around the query within the article text or
      summary. The max_length parameter controls the length of the snippet.
      """
      logger.info("Tool: Getting query-focused summary for article: %s, query: %s", title, query)
      summary = wikipedia_client.summarize_for_query(title, query, max_length=max_length)
      return {"title": title, "query": query, "summary": summary}

• wikipedia_mcp/wikipedia_client.py:900-944 (helper)

  The WikipediaClient.summarize_for_query() method — core helper logic that fetches the page text, finds the query in the text, and returns a snippet around it. Falls back to page summary if query not found.

  def summarize_for_query(self, title: str, query: str, max_length: int = 250) -> str:
      """
      Get a summary of a Wikipedia article tailored to a specific query.
  
      This is a simplified implementation that returns a snippet around the query.
  
      Args:
          title: The title of the Wikipedia article.
          query: The query to focus the summary on.
          max_length: The maximum length of the summary.
  
      Returns:
          A query-focused summary.
      """
      try:
          page = self.wiki.page(title)
          if not page.exists():
              return f"No Wikipedia article found for '{title}'."
  
          text_content = page.text
          query_lower = query.lower()
          text_lower = text_content.lower()
  
          start_index = text_lower.find(query_lower)
          if start_index == -1:
              # If query not found, return the beginning of the summary or article text
              summary_part = page.summary[:max_length]
              if not summary_part:
                  summary_part = text_content[:max_length]
              return summary_part + "..." if len(summary_part) >= max_length else summary_part
  
          # Try to get context around the query
          context_start = max(0, start_index - (max_length // 2))
          context_end = min(len(text_content), start_index + len(query) + (max_length // 2))
  
          snippet = text_content[context_start:context_end]
  
          if len(snippet) > max_length:
              snippet = snippet[:max_length]
  
          return snippet + "..." if len(snippet) >= max_length or context_end < len(text_content) else snippet
  
      except Exception as e:
          logger.error(f"Error generating query-focused summary for '{title}': {e}")
          return f"Error generating query-focused summary for '{title}': {str(e)}"

• wikipedia_mcp/schemas.py:61-64 (schema)

  The QuerySummaryResponse Pydantic model defining the output schema for the tool (title, query, summary fields).

  class QuerySummaryResponse(MCPBaseModel):
      title: str
      query: str
      summary: str

• wikipedia_mcp/server.py:160-175 (registration)

  The register_tool decorator function that registers the tool under both the short name and the prefixed 'wikipedia_' name.

  def register_tool(name: str, output_schema: dict[str, Any]):
      def decorator(func):
          server.tool(
              func,
              name=name,
              annotations=_READ_ONLY_TOOL_ANNOTATIONS,
              output_schema=output_schema,
          )
          server.tool(
              func,
              name=f"wikipedia_{name}",
              annotations=_READ_ONLY_TOOL_ANNOTATIONS,
              output_schema=output_schema,
          )
          return func

• wikipedia_mcp/wikipedia_client.py:323-325 (helper)

  LRU cache wrapping applied to summarize_for_query method for performance.

  self.summarize_for_query = functools.lru_cache(maxsize=128)(  # type: ignore[method-assign]
      self.summarize_for_query
  )